RhodeCode

  ///

  /// \brief Maximum cardinality matching in general graphs

  ///

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

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

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

  ///

  /// The dual solution of the problem is a map of the nodes to

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

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

  /// minus the number of barrier nodes is a lower bound on the

  /// unmatched nodes, and the matching is optimal if and only if this bound is

  ///

  template <typename GR>

  class MaxMatching {

  public:

    /// The graph type of the algorithm

    typedef GR Graph;

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

    MatchingMap;

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

      A = -1,

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

    };

    typedef typename Graph::template NodeMap<Status> StatusMap;

  private:

    Arc matching(const Node& n) const {

      return (*_matching)[n];

    }

    /// \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.

    /// decomposition.

    ///

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

    /// in the Edmonds-Gallai decomposition.

      return (*_status)[n];

    }

    /// \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.

    bool barrier(const Node& n) const {

  /// 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 WM The type edge weight map. The default type is 

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

#ifdef DOXYGEN

  template <typename GR, typename WM>

    typedef WM WeightMap;

    /// The value type of the edge weights

    typedef typename WeightMap::Value Value;

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

    MatchingMap;

    /// \brief Scaling factor for dual solution

    ///

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

    ///

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

      Value sum = 0;

      for (NodeIt n(_graph); n != INVALID; ++n) {

        if ((*_matching)[n] != INVALID) {

          sum += _weight[(*_matching)[n]];

    Arc matching(const Node& node) const {

      return (*_matching)[node];

    }

    /// \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.

  /// 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 WM The type edge weight map. The default type is 

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

#ifdef DOXYGEN

  template <typename GR, typename WM>

    /// according to the value type.

    static const int dualScale =

      std::numeric_limits<Value>::is_integer ? 4 : 1;

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

    MatchingMap;

  private:

    ///

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

    ///

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

      Value sum = 0;

      for (NodeIt n(_graph); n != INVALID; ++n) {

        if ((*_matching)[n] != INVALID) {

          sum += _weight[(*_matching)[n]];

    Arc matching(const Node& node) const {

      return (*_matching)[node];

    }

    /// \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.

  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.barrier(n);

}

void checkMaxWeightedMatchingCompile()

{

  mat_test.init();

  mat_test.start();

  mat_test.run();

  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();

  mat_test.init();

  mat_test.start();

  mat_test.run();

  const_mat_test.matching(e);

  const_mat_test.matching(n);

  const_mat_test.mate(n);

  int k = 0;

  const_mat_test.dualValue();

  int barrier_num = 0;

  for (NodeIt n(graph); n != INVALID; ++n) {

          mm.matching(n) != INVALID, "Wrong Gallai-Edmonds decomposition");

      ++barrier_num;

    } else {

      comp.insert(n);

    }

      check(e == mm.matching(graph.u(e)), "Wrong matching");

      check(e == mm.matching(graph.v(e)), "Wrong matching");

      ++num;

    }

          "Wrong Gallai-Edmonds decomposition");

          "Wrong Gallai-Edmonds decomposition");

      comp.join(graph.u(e), graph.v(e));

    }

  }

  std::set<int> comp_root;

  int odd_comp_num = 0;

  for (NodeIt n(graph); n != INVALID; ++n) {

      int root = comp.find(n);

      if (comp_root.find(root) == comp_root.end()) {

        comp_root.insert(root);

        if (comp.size(n) % 2 == 1) {