RhodeCode

This group contains the algorithms for calculating

finding a subset of the edges for which each node has at most one incident

edge.

  /// \brief Maximum cardinality matching in general graphs

  /// This class implements Edmonds' alternating forest matching algorithm

  /// for finding a maximum cardinality matching in a general graph. 

  /// It can be started from an arbitrary initial matching 

  /// (the default is the empty one).

  /// \ref MaxMatching::Status "Status", having values \c EVEN (or \c D),

  /// \c ODD (or \c A) and \c MATCHED (or \c C) defining the Gallai-Edmonds

  /// decomposition of the graph. The nodes in \c EVEN/D induce a subgraph

  /// with factor-critical components, the nodes in \c ODD/A form the

  /// canonical barrier, and the nodes in \c MATCHED/C induce a graph having

  /// a perfect matching. The number of the factor-critical components

  /// tight. This decomposition can be obtained by calling \c

  /// \tparam GR The graph type the algorithm runs on.

    /// The graph type of the algorithm

    ///\brief Status constants for Gallai-Edmonds decomposition.

    ///These constants are used for indicating the Gallai-Edmonds 

    ///decomposition of a graph. The nodes with status \c EVEN (or \c D)

    ///induce a subgraph with factor-critical components, the nodes with

    ///status \c ODD (or \c A) form the canonical barrier, and the nodes

    ///with status \c MATCHED (or \c C) induce a subgraph having a 

    ///perfect matching.

      EVEN = 1,       ///< = 1. (\c D is an alias for \c EVEN.)

      D = 1,

      MATCHED = 0,    ///< = 0. (\c C is an alias for \c MATCHED.)

      C = 0,

      ODD = -1,       ///< = -1. (\c A is an alias for \c ODD.)

      A = -1,

      UNMATCHED = -2  ///< = -2.

    /// \name Execution Control

    /// \c run() member function.\n

    /// If you need better control on the execution, you have to call

    /// one of the functions \ref init(), \ref greedyInit() or

    /// \ref matchingInit() first, then you can start the algorithm with

    /// \ref startSparse() or \ref startDense().

    /// \brief Set the initial matching to the empty matching.

    /// This function sets the initial matching to the empty matching.

    /// \brief Find an initial matching in a greedy way.

    /// This function finds an initial matching in a greedy way.

    /// \brief Initialize the matching from a map.

    /// This function initializes the matching from a \c bool valued edge

    /// map. This map should have the property that there are no two incident

    /// edges with \c true value, i.e. it really contains a matching.

    /// \brief Start Edmonds' algorithm

    /// This function runs the original Edmonds' algorithm.

    ///

    /// \pre \ref Init(), \ref greedyInit() or \ref matchingInit() must be

    /// called before using this function.

    /// \brief Start Edmonds' algorithm with a heuristic improvement 

    /// for dense graphs

    /// This function runs Edmonds' algorithm with a heuristic of postponing

    ///

    /// \pre \ref Init(), \ref greedyInit() or \ref matchingInit() must be

    /// called before using this function.

    /// \brief Run Edmonds' algorithm

    /// This function runs Edmonds' algorithm. An additional heuristic of 

    /// postponing shrinks is used for relatively dense graphs 

    /// (for which <tt>m>=2*n</tt> holds).

    /// \name Primal Solution

    /// Functions to get the primal solution, i.e. the maximum matching.

    /// \brief Return the size (cardinality) of the matching.

    /// This function returns the size (cardinality) of the current matching. 

    /// After run() it returns the size of the maximum matching in the graph.

    /// \brief Return \c true if the given edge is in the matching.

    /// This function returns \c true if the given edge is in the current 

    /// matching.

    /// \brief Return the matching arc (or edge) incident to the given node.

    /// This function returns the matching arc (or edge) incident to the

    /// given node in the current matching or \c INVALID if the node is 

    /// not covered by the matching.

    /// \brief Return the mate of the given node.

    /// This function returns the mate of the given node in the current 

    /// matching or \c INVALID if the node is not covered by the matching.

    /// \name Dual Solution

    /// Functions to get the dual solution, i.e. the Gallai-Edmonds 

    /// decomposition.

    /// \brief Return the status of the given node in the Edmonds-Gallai

    /// This function returns the \ref Status "status" of the given node

    /// in the Edmonds-Gallai decomposition.

    /// \brief Return \c true if the given node is in the barrier.

    /// This function returns \c true if the given node is in the barrier.

  /// The maximum weighted matching problem is to find a subset of the 

  /// edges in an undirected graph with maximum overall weight for which 

  /// each node has at most one incident edge.

  /// It can be formulated with the following linear program.

  /// following.

  /// The algorithm can be executed with the run() function. 

  /// After it the matching (the primal solution) and the dual solution

  /// can be obtained using the query functions and the 

  /// \ref MaxWeightedMatching::BlossomIt "BlossomIt" nested class, 

  /// which is able to iterate on the nodes of a blossom. 

  /// If the value type is integer, then the dual solution is multiplied

  /// by \ref MaxWeightedMatching::dualScale "4".

  ///

  /// \tparam GR The graph type the algorithm runs on.

  /// \tparam WM The type edge weight map. The default type is 

  /// \ref concepts::Graph::EdgeMap "GR::EdgeMap<int>".

#ifdef DOXYGEN

  template <typename GR, typename WM>

#else

#endif

    /// The graph type of the algorithm

    /// The type of the edge weight map

    /// The value type of the edge weights

    typedef typename Graph::template NodeMap<typename Graph::Arc>

    MatchingMap;

    /// Scaling factor for dual solution. It is equal to 4 or 1

    /// \name Execution Control

    /// \ref run() member function.

    /// This function initializes the algorithm.

    /// \brief Start the algorithm

    /// This function starts the algorithm.

    ///

    /// \pre \ref init() must be called before using this function.

    /// \brief Run the algorithm.

    /// This method runs the \c %MaxWeightedMatching algorithm.

    /// \name Primal Solution

    /// Functions to get the primal solution, i.e. the maximum weighted 

    /// matching.\n

    /// Either \ref run() or \ref start() function should be called before

    /// using them.

    /// \brief Return the weight of the matching.

    /// This function returns the weight of the found matching.

    ///

    /// \pre Either run() or start() must be called before using this function.

    /// \brief Return the size (cardinality) of the matching.

    /// This function returns the size (cardinality) of the found matching.

    ///

    /// \pre Either run() or start() must be called before using this function.

    /// \brief Return \c true if the given edge is in the matching.

    /// This function returns \c true if the given edge is in the found 

    /// matching.

    ///

    /// \pre Either run() or start() must be called before using this function.

    /// \brief Return the matching arc (or edge) incident to the given node.

    /// This function returns the matching arc (or edge) incident to the

    /// given node in the found matching or \c INVALID if the node is 

    /// not covered by the matching.

    ///

    /// \pre Either run() or start() must be called before using this function.

    /// \brief Return the mate of the given node.

    /// This function returns the mate of the given node in the found 

    /// matching or \c INVALID if the node is not covered by the matching.

    ///

    /// \pre Either run() or start() must be called before using this function.

    /// \name Dual Solution

    /// Functions to get the dual solution.\n

    /// Either \ref run() or \ref start() function should be called before

    /// using them.

    /// \brief Return the value of the dual solution.

    /// This function returns the value of the dual solution. 

    /// It should be equal to the primal value scaled by \ref dualScale 

    /// "dual scale".

    ///

    /// \pre Either run() or start() must be called before using this function.

    /// \brief Return the dual value (potential) of the given node.

    /// This function returns the dual value (potential) of the given node.

    ///

    /// \pre Either run() or start() must be called before using this function.

    /// \brief Return the number of the blossoms in the basis.

    /// This function returns the number of the blossoms in the basis.

    ///

    /// \pre Either run() or start() must be called before using this function.

    /// \brief Return the number of the nodes in the given blossom.

    /// This function returns the number of the nodes in the given blossom.

    ///

    /// \pre Either run() or start() must be called before using this function.

    /// \see BlossomIt

    /// \brief Return the dual value (ptential) of the given blossom.

    /// This function returns the dual value (ptential) of the given blossom.

    ///

    /// \pre Either run() or start() must be called before using this function.

    /// \brief Iterator for obtaining the nodes of a blossom.

    /// This class provides an iterator for obtaining the nodes of the 

    /// given blossom. It lists a subset of the nodes.

    /// Before using this iterator, you must allocate a 

    /// MaxWeightedMatching class and execute it.

      /// Constructor to get the nodes of the given variable.

      ///

      /// \pre Either \ref MaxWeightedMatching::run() "algorithm.run()" or 

      /// \ref MaxWeightedMatching::start() "algorithm.start()" must be 

      /// called before initializing this iterator.

      /// \brief Conversion to \c Node.

      /// Conversion to \c Node.

  /// The maximum weighted perfect matching problem is to find a subset of 

  /// the edges in an undirected graph with maximum overall weight for which 

  /// each node has exactly one incident edge.

  /// It can be formulated with the following linear program.

  /// following.

  /// The algorithm can be executed with the run() function. 

  /// After it the matching (the primal solution) and the dual solution

  /// can be obtained using the query functions and the 

  /// \ref MaxWeightedPerfectMatching::BlossomIt "BlossomIt" nested class, 

  /// which is able to iterate on the nodes of a blossom. 

  /// If the value type is integer, then the dual solution is multiplied

  /// by \ref MaxWeightedMatching::dualScale "4".

  ///

  /// \tparam GR The graph type the algorithm runs on.

  /// \tparam WM The type edge weight map. The default type is 

  /// \ref concepts::Graph::EdgeMap "GR::EdgeMap<int>".

#ifdef DOXYGEN

  template <typename GR, typename WM>

#else

#endif

    /// The graph type of the algorithm

    /// The type of the edge weight map

    /// The value type of the edge weights

    /// \name Execution Control

    /// \ref run() member function.

    /// This function initializes the algorithm.

    /// \brief Start the algorithm

    /// This function starts the algorithm.

    ///

    /// \pre \ref init() must be called before using this function.

    /// \brief Run the algorithm.

    /// This method runs the \c %MaxWeightedPerfectMatching algorithm.

    /// \note mwpm.run() is just a shortcut of the following code.

    ///   mwpm.init();

    ///   mwpm.start();

    /// \name Primal Solution

    /// Functions to get the primal solution, i.e. the maximum weighted 

    /// perfect matching.\n

    /// Either \ref run() or \ref start() function should be called before

    /// using them.

    /// \brief Return the weight of the matching.

    /// This function returns the weight of the found matching.

    ///

    /// \pre Either run() or start() must be called before using this function.

    /// \brief Return \c true if the given edge is in the matching.

    /// This function returns \c true if the given edge is in the found 

    /// matching.

    ///

    /// \pre Either run() or start() must be called before using this function.

    /// \brief Return the matching arc (or edge) incident to the given node.

    /// This function returns the matching arc (or edge) incident to the

    /// given node in the found matching or \c INVALID if the node is 

    /// not covered by the matching.

    ///

    /// \pre Either run() or start() must be called before using this function.

    /// \brief Return the mate of the given node.

    /// This function returns the mate of the given node in the found 

    /// matching or \c INVALID if the node is not covered by the matching.

    ///

    /// \pre Either run() or start() must be called before using this function.

    /// \name Dual Solution

    /// Functions to get the dual solution.\n

    /// Either \ref run() or \ref start() function should be called before

    /// using them.

    /// \brief Return the value of the dual solution.

    /// This function returns the value of the dual solution. 

    /// It should be equal to the primal value scaled by \ref dualScale 

    /// "dual scale".

    ///

    /// \pre Either run() or start() must be called before using this function.

    /// \brief Return the dual value (potential) of the given node.

    /// This function returns the dual value (potential) of the given node.

    ///

    /// \pre Either run() or start() must be called before using this function.

    /// \brief Return the number of the blossoms in the basis.

    /// This function returns the number of the blossoms in the basis.

    ///

    /// \pre Either run() or start() must be called before using this function.

    /// \brief Return the number of the nodes in the given blossom.

    /// This function returns the number of the nodes in the given blossom.

    ///

    /// \pre Either run() or start() must be called before using this function.

    /// \see BlossomIt

    /// \brief Return the dual value (ptential) of the given blossom.

    /// This function returns the dual value (ptential) of the given blossom.

    ///

    /// \pre Either run() or start() must be called before using this function.

    /// \brief Iterator for obtaining the nodes of a blossom.

    /// This class provides an iterator for obtaining the nodes of the 

    /// given blossom. It lists a subset of the nodes.

    /// Before using this iterator, you must allocate a 

    /// MaxWeightedPerfectMatching class and execute it.

      /// Constructor to get the nodes of the given variable.

      ///

      /// \pre Either \ref MaxWeightedPerfectMatching::run() "algorithm.run()" 

      /// or \ref MaxWeightedPerfectMatching::start() "algorithm.start()" 

      /// must be called before initializing this iterator.

      /// \brief Conversion to \c Node.

      /// Conversion to \c Node.

      /// This function checks whether the iterator is invalid.

      /// This function checks whether the iterator is valid.

#include <lemon/concepts/graph.h>

#include <lemon/concepts/maps.h>

#include <lemon/math.h>

void checkMaxMatchingCompile()

{

  typedef concepts::Graph Graph;

  typedef Graph::Node Node;

  typedef Graph::Edge Edge;

  typedef Graph::EdgeMap<bool> MatMap;

  Graph g;

  Node n;

  Edge e;

  MatMap mat(g);

  MaxMatching<Graph> mat_test(g);

  const MaxMatching<Graph>&

    const_mat_test = mat_test;

  mat_test.init();

  mat_test.greedyInit();

  mat_test.matchingInit(mat);

  mat_test.startSparse();

  mat_test.startDense();

  mat_test.run();

  const_mat_test.matchingSize();

  const_mat_test.matching(e);

  const_mat_test.matching(n);

  const_mat_test.mate(n);

  MaxMatching<Graph>::Status stat = 

    const_mat_test.decomposition(n);

  const_mat_test.barrier(n);

  ignore_unused_variable_warning(stat);

}

void checkMaxWeightedMatchingCompile()

{

  typedef concepts::Graph Graph;

  typedef Graph::Node Node;

  typedef Graph::Edge Edge;

  typedef Graph::EdgeMap<int> WeightMap;

  Graph g;

  Node n;

  Edge e;

  WeightMap w(g);

  MaxWeightedMatching<Graph> mat_test(g, w);

  const MaxWeightedMatching<Graph>&

    const_mat_test = mat_test;

  mat_test.init();

  mat_test.start();

  mat_test.run();

  const_mat_test.matchingValue();

  const_mat_test.matchingSize();

  const_mat_test.matching(e);

  const_mat_test.matching(n);

  const_mat_test.mate(n);

  int k = 0;

  const_mat_test.dualValue();

  const_mat_test.nodeValue(n);

  const_mat_test.blossomNum();

  const_mat_test.blossomSize(k);

  const_mat_test.blossomValue(k);

}

void checkMaxWeightedPerfectMatchingCompile()

{

  typedef concepts::Graph Graph;

  typedef Graph::Node Node;

  typedef Graph::Edge Edge;

  typedef Graph::EdgeMap<int> WeightMap;

  Graph g;

  Node n;

  Edge e;

  WeightMap w(g);

  MaxWeightedPerfectMatching<Graph> mat_test(g, w);

  const MaxWeightedPerfectMatching<Graph>&

    const_mat_test = mat_test;

  mat_test.init();

  mat_test.start();

  mat_test.run();

  const_mat_test.matchingValue();

  const_mat_test.matching(e);

  const_mat_test.matching(n);

  const_mat_test.mate(n);

  int k = 0;

  const_mat_test.dualValue();

  const_mat_test.nodeValue(n);

  const_mat_test.blossomNum();

  const_mat_test.blossomSize(k);

  const_mat_test.blossomValue(k);

}