Ticket #66: 5ecf45167d4e.patch

lemon/gomory_hu_tree.h

@@ -228 +228 @@
       
       while (sn != tn) {
         if ((*_order)[sn] < (*_order)[tn]) {
-          if ((*_weight)[tn] < value) value = (*_weight)[tn];
+          if ((*_weight)[tn] <= value) value = (*_weight)[tn];
           tn = (*_pred)[tn];
         } else {
-          if ((*_weight)[sn] < value) value = (*_weight)[sn];
+          if ((*_weight)[sn] <= value) value = (*_weight)[sn];
           sn = (*_pred)[sn];
         }
       }
@@ -249 +249 @@
     template <typename CutMap>
     Value minCutMap(const Node& s, const Node& t, CutMap& cutMap) const {
       Node sn = s, tn = t;
-
+      bool s_root=false;
       Node rn = INVALID;
       Value value = std::numeric_limits<Value>::max();
       
       while (sn != tn) {
         if ((*_order)[sn] < (*_order)[tn]) {
-          if ((*_weight)[tn] < value) {
+          if ((*_weight)[tn] <= value) {
             rn = tn;
+            s_root = false;
             value = (*_weight)[tn];
           }
           tn = (*_pred)[tn];
         } else {
-          if ((*_weight)[sn] < value) {
+          if ((*_weight)[sn] <= value) {
             rn = sn;
+            s_root = true;
             value = (*_weight)[sn];
           }
           sn = (*_pred)[sn];
@@ -271 +273 @@
 
       typename Graph::template NodeMap<bool> reached(_graph, false);
       reached.set(_root, true);
-      cutMap.set(_root, false);
+      cutMap.set(_root, !s_root);
       reached.set(rn, true);
-      cutMap.set(rn, true);
+      cutMap.set(rn, s_root);
 
+      std::vector<Node> st;
       for (NodeIt n(_graph); n != INVALID; ++n) {
-        std::vector<Node> st;
-        Node nn = n;
+        st.clear();
+        Node nn = n;
         while (!reached[nn]) {
           st.push_back(nn);
           nn = (*_pred)[nn];
@@ -291 +294 @@
       return value;
     }
 
+    friend class MinCutNodeIt;
+
+    class MinCutNodeIt
+    {
+      bool _side;
+      typename Graph::NodeIt _node_it;
+      typename Graph::template NodeMap<bool> _cut;
+    public:
+      MinCutNodeIt(GomoryHuTree const &gomory,
+                   const Node& s, const Node& t, bool side=true)
+        : _side(side), _cut(gomory._graph)
+      {
+        gomory.minCutMap(s,t,_cut);
+        for(_node_it=typename Graph::NodeIt(gomory._graph);
+            _node_it!=INVALID && _cut[_node_it]!=_side;
+            ++_node_it) {}
+      }
+      operator typename Graph::Node() const
+      {
+        return _node_it;
+      }
+      bool operator==(Invalid) { return _node_it==INVALID; }
+      bool operator!=(Invalid) { return _node_it!=INVALID; }
+      ///Next node
+      MinCutNodeIt &operator++()
+      {
+        for(++_node_it;_node_it!=INVALID&&_cut[_node_it]!=_side;++_node_it) {}
+        return *this;
+      }
+      ///Postfix incrementation
+
+      ///\warning This incrementation
+      ///returns a \c Node, not a \ref MinCutNodeIt, as one may
+      ///expect.
+      typename Graph::Node operator++(int)
+      {
+        typename Graph::Node n=*this;
+        ++(*this);
+        return n;
+      }
+    };
+    
+    friend class MinCutArcIt;
+    
+    class MinCutArcIt
+    {
+      bool _side;
+      const Graph &_graph;
+      typename Graph::NodeIt _node_it;
+      typename Graph::OutArcIt _arc_it;
+      typename Graph::template NodeMap<bool> _cut;
+      void step()
+      {
+        ++_arc_it;
+        while(_node_it!=INVALID && _arc_it==INVALID)
+          {
+            for(++_node_it;_node_it!=INVALID&&!_cut[_node_it];++_node_it) {}
+            if(_node_it!=INVALID)
+              _arc_it=typename Graph::OutArcIt(_graph,_node_it);
+          }
+      }
+      
+    public:
+      MinCutArcIt(GomoryHuTree const &gomory,
+                  const Node& s, const Node& t, bool side=true)
+        : _graph(gomory._graph), _cut(_graph)
+      {
+        gomory.minCutMap(s,t,_cut);
+        if(!side)
+          for(typename Graph::NodeIt n(_graph);n!=INVALID;++n)
+            _cut[n]=!_cut[n];
+
+        for(_node_it=typename Graph::NodeIt(_graph);
+            _node_it!=INVALID && !_cut[_node_it];
+            ++_node_it) {}
+        _arc_it = _node_it!=INVALID ?
+          typename Graph::OutArcIt(_graph,_node_it) : INVALID;
+        while(_node_it!=INVALID && _arc_it == INVALID)
+          {
+            for(++_node_it; _node_it!=INVALID&&!_cut[_node_it]; ++_node_it) {}
+            if(_node_it!=INVALID)
+              _arc_it= typename Graph::OutArcIt(_graph,_node_it);
+          }
+        while(_arc_it!=INVALID && _cut[_graph.target(_arc_it)]) step();
+      }
+      operator typename Graph::Arc() const
+      {
+        return _arc_it;
+      }
+      operator typename Graph::Edge() const
+      {
+        return _arc_it;
+      }
+      bool operator==(Invalid) { return _node_it==INVALID; }
+      bool operator!=(Invalid) { return _node_it!=INVALID; }
+      ///Next node
+      MinCutArcIt &operator++()
+      {
+        step();
+        while(_arc_it!=INVALID && _cut[_graph.target(_arc_it)]) step();
+        return *this;
+      }
+      ///Postfix incrementation
+      
+      ///\warning This incrementation
+      ///returns a \c Arc, not a \ref MinCutArcIt, as one may
+      ///expect.
+      typename Graph::Arc operator++(int)
+      {
+        typename Graph::Arc a=*this;
+        ++(*this);
+        return a;
+      }
+    };
+
   };
 
 }

test/gomory_hu_test.cc

@@ -77 +77 @@
       check(pf.flowValue() == ght.minCutValue(u, v), "Wrong cut 1");
       check(cm[u] != cm[v], "Wrong cut 3");
       check(pf.flowValue() == cutValue(graph, cm, capacity), "Wrong cut 2");
+
+      int sum=0;
+      for(GomoryHuTree<Graph>::MinCutArcIt a(ght, u, v);a!=INVALID;++a)
+        sum+=capacity[a]; 
+      check(sum == ght.minCutValue(u, v), "Problem with MinCutArcIt");
+
+      sum=0;
+      for(GomoryHuTree<Graph>::MinCutNodeIt n(ght, u, v,true);n!=INVALID;++n)
+        sum++;
+      for(GomoryHuTree<Graph>::MinCutNodeIt n(ght, u, v,false);n!=INVALID;++n)
+        sum++;
+      check(sum == countNodes(graph), "Problem with MinCutNodeIt");
       
     }
   }