Kruskal.H

Go to the documentation of this file.

 
/*
                          Aleph_w
 
  Data structures & Algorithms
  version 2.0.0b
  https://github.com/lrleon/Aleph-w
 
  This file is part of Aleph-w library
 
  Copyright (c) 2002-2026 Leandro Rabindranath Leon
 
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:
 
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
 
  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  SOFTWARE.
*/
 
 
# ifndef KRUSKAL_H
# define KRUSKAL_H
 
# include <ahFunction.H>
# include <tpl_agraph.H>
# include <tpl_graph_utils.H>
# include <tpl_test_acyclique.H>
# include <tpl_union.H>
# include <ah-errors.H>
 
namespace Aleph
{
  template <class GT,
            class Distance = Dft_Dist<GT>,
            class SA = Dft_Show_Arc<GT>>
  class Kruskal_Min_Spanning_Tree
  {
    Distance dist_val;
    Distance & dist;
    SA sa;
    bool painted;
 
    struct Init_Node
    {
      long count;
 
      Init_Node() noexcept : count(0) { /* empty */ }
 
      void operator ()(const GT &, typename GT::Node *p) noexcept
      {
        NODE_COUNTER(p) = count++;
        NODE_BITS(p).set_bit(Aleph::Spanning_Tree, false);
      }
    };
 
    static bool arc_is_in_tree(Fixed_Relation & tree, long i, long j) noexcept
    {
      return tree.are_connected(i, j);
    }
 
  public:
    Kruskal_Min_Spanning_Tree(Distance __dist = Distance(), SA __sa = SA())
      : dist_val(__dist), dist(dist_val), sa(__sa), painted(false)
    {
      /* empty */
    }
 
    Kruskal_Min_Spanning_Tree(Distance & __dist, SA __sa = SA())
      : dist_val(), dist(__dist), sa(__sa), painted(false)
    {
      /* empty */
    }
 
    [[nodiscard]] bool is_painted() const noexcept { return painted; }
 
    template <class G, class GT_SA>
    struct Paint_Filt
    {
      GT_SA & sa;
 
      Paint_Filt(GT_SA & __sa) : sa(__sa) { /* empty */ }
 
      bool operator ()(typename G::Arc *a) const noexcept
      {
        if (not sa(a))
          return false;
 
        return IS_ARC_VISITED(a, Aleph::Spanning_Tree);
      }
    };
 
    void paint_min_spanning_tree(const GT & g)
    {
      ah_domain_error_if(g.is_digraph()) << "g is a digraph";
 
      g.reset_bit_arcs(Aleph::Spanning_Tree); // clear arc marking bits
      Operate_On_Nodes<GT, Init_Node>()(g, Init_Node());
 
      typedef Distance_Compare<GT, Distance> DCMP;
      DCMP comp(dist);
      // Safe const_cast: sort_arcs only changes physical arc order, not structure
      const_cast<GT &>(g).template sort_arcs<DCMP>(comp);
      const size_t V = g.get_num_nodes();
 
      Fixed_Relation tree(V);
 
      // Traverse sorted arcs of g until all nodes are in one component
      for (Arc_Iterator<GT, SA> it(g, sa); tree.get_num_blocks() > 1 and
                                           it.has_curr(); it.next_ne())
        { // next smallest arc
          auto arc = it.get_current_arc_ne();
          const long i = NODE_COUNTER(g.get_src_node(arc));
          const long j = NODE_COUNTER(g.get_tgt_node(arc));
          if (arc_is_in_tree(tree, i, j))
            continue;
 
          tree.join(i, j);
          ARC_BITS(arc).set_bit(Aleph::Spanning_Tree, true);
        }
 
      painted = true;
    }
 
    void paint_min_spanning_tree(const GT & g, GT & tree)
    {
      paint_min_spanning_tree(g);
      clear_graph(tree); // clear destination graph
 
      for (typename GT::Node_Iterator it(g); it.has_curr(); it.next_ne())
        {
          auto gp = it.get_curr();
          auto tp = tree.insert_node(gp->get_info());
          GT::map_nodes(gp, tp);
        }
 
      typedef Paint_Filt<GT, SA> F;
      for (Arc_Iterator<GT, F> it(g, F(sa)); it.has_curr(); it.next_ne())
        {
          auto ga = it.get_current_arc_ne();
          auto tsrc = mapped_node<GT>(g.get_src_node(ga));
          auto ttgt = mapped_node<GT>(g.get_tgt_node(ga));
          auto ta = tree.insert_arc(tsrc, ttgt, ga->get_info());
          GT::map_arcs(ga, ta);
        }
    }
 
    void operator ()(const GT & g, GT & tree)
    {
      paint_min_spanning_tree(g, tree);
    }
 
    void operator ()(const GT & g)
    {
      paint_min_spanning_tree(g);
    }
  };
} // end namespace Aleph
 
# endif // KRUSKAL_H