Changeset 372:e6a156fc186d in lemon-0.x for src/work/jacint/preflow.h

Timestamp:

04/22/04 16:11:28 (20 years ago)

Author:

jacint

Branch:

default

Phase:

public

Convert:

svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@502

Message:

 

File:

• src/work/jacint/preflow.h (modified) (12 diffs)

src/work/jacint/preflow.h

@@ -1 +1 @@
 // -*- C++ -*-
+
+//run gyorsan tudna adni a minmincutot a 2 fazis elejen , ne vegyuk be konstruktorba egy cutmapet?
+//constzero jo igy?
+
+//majd marci megmondja betegyem-e bfs-t meg resgraphot
+
 /*
 Heuristics: 
@@ -13 +19 @@
 Constructors:
 
-Preflow(Graph, Node, Node, CapMap, FlowMap)
+Preflow(Graph, Node, Node, CapMap, FlowMap, bool) : bool must be false if 
+     FlowMap is not constant zero, and should be true if it is
 
 Members:
@@ -30 +37 @@
      a min cut. M should be a map of bools initialized to false.
 
+FIXME reset
+
 */
 
@@ -45 +54 @@
   template <typename Graph, typename T, 
             typename CapMap=typename Graph::EdgeMap<T>, 
-            typename FlowMap=typename Graph::EdgeMap<T> >
+            typename FlowMap=typename Graph::EdgeMap<T> >
   class Preflow {
     
@@ -60 +69 @@
     FlowMap& flow;
     T value;
+    bool constzero;
 
   public:
-    Preflow(const Graph& _G, Node _s, Node _t, const CapMap& _capacity, 
-            FlowMap& _flow ) :
-      G(_G), s(_s), t(_t), capacity(_capacity), flow(_flow) {}
-
+    Preflow(Graph& _G, Node _s, Node _t, CapMap& _capacity, 
+            FlowMap& _flow, bool _constzero ) :
+      G(_G), s(_s), t(_t), capacity(_capacity), flow(_flow), constzero(_constzero) {}
+    
+    
     void run() {
+      
+      value=0;                //for the subsequent runs
 
       bool phase=0;        //phase 0 is the 1st phase, phase 1 is the 2nd
@@ -90 +103 @@
       typename Graph::NodeMap<T> excess(G); 
 
-      std::vector<Node> active(n,INVALID);
+      std::vector<Node> active(n-1,INVALID);
       typename Graph::NodeMap<Node> next(G,INVALID);
       //Stack of the active nodes in level i < n.
@@ -102 +115 @@
       */
 
-      /*Reverse_bfs from t, to find the starting level.*/
-      level.set(t,0);
-      std::queue<Node> bfs_queue;
-      bfs_queue.push(t);
-
-      while (!bfs_queue.empty()) {
-
-        Node v=bfs_queue.front();       
-        bfs_queue.pop();
-        int l=level[v]+1;
-
-        InEdgeIt e;
-        for(G.first(e,v); G.valid(e); G.next(e)) {
-          Node w=G.tail(e);
-          if ( level[w] == n && w != s ) {
-            bfs_queue.push(w);
-            Node first=level_list[l];
-            if ( G.valid(first) ) left.set(first,w);
-            right.set(w,first);
-            level_list[l]=w;
-            level.set(w, l);
-          }
-        }
-      }
-      
-      level.set(s,n);
-      
-
-      /* Starting flow. It is everywhere 0 at the moment. */     
-      OutEdgeIt e;
-      for(G.first(e,s); G.valid(e); G.next(e)) 
+
+      if ( constzero ) {
+     
+        /*Reverse_bfs from t, to find the starting level.*/
+        level.set(t,0);
+        std::queue<Node> bfs_queue;
+        bfs_queue.push(t);
+        
+        while (!bfs_queue.empty()) {
+          
+          Node v=bfs_queue.front();     
+          bfs_queue.pop();
+          int l=level[v]+1;
+          
+          InEdgeIt e;
+          for(G.first(e,v); G.valid(e); G.next(e)) {
+            Node w=G.tail(e);
+            if ( level[w] == n && w != s ) {
+              bfs_queue.push(w);
+              Node first=level_list[l];
+              if ( G.valid(first) ) left.set(first,w);
+              right.set(w,first);
+              level_list[l]=w;
+              level.set(w, l);
+            }
+          }
+        }
+
+        //the starting flow
+        OutEdgeIt e;
+        for(G.first(e,s); G.valid(e); G.next(e)) 
         {
           T c=capacity[e];
@@ -146 +159 @@
           }
         }
+      }
+      else 
+      {
+        
+        /*
+          Reverse_bfs from t in the residual graph, 
+          to find the starting level.
+        */
+        level.set(t,0);
+        std::queue<Node> bfs_queue;
+        bfs_queue.push(t);
+        
+        while (!bfs_queue.empty()) {
+          
+          Node v=bfs_queue.front();     
+          bfs_queue.pop();
+          int l=level[v]+1;
+          
+          InEdgeIt e;
+          for(G.first(e,v); G.valid(e); G.next(e)) {
+            if ( capacity[e] == flow[e] ) continue;
+            Node w=G.tail(e);
+            if ( level[w] == n && w != s ) {
+              bfs_queue.push(w);
+              Node first=level_list[l];
+              if ( G.valid(first) ) left.set(first,w);
+              right.set(w,first);
+              level_list[l]=w;
+              level.set(w, l);
+            }
+          }
+            
+          OutEdgeIt f;
+          for(G.first(f,v); G.valid(f); G.next(f)) {
+            if ( 0 == flow[f] ) continue;
+            Node w=G.head(f);
+            if ( level[w] == n && w != s ) {
+              bfs_queue.push(w);
+              Node first=level_list[l];
+              if ( G.valid(first) ) left.set(first,w);
+              right.set(w,first);
+              level_list[l]=w;
+              level.set(w, l);
+            }
+          }
+        }
+      
+        
+        /*
+          Counting the excess
+        */
+        NodeIt v;
+        for(G.first(v); G.valid(v); G.next(v)) {
+          T exc=0;
+
+          InEdgeIt e;
+          for(G.first(e,v); G.valid(e); G.next(e)) exc+=flow[e];
+          OutEdgeIt f;
+          for(G.first(f,v); G.valid(f); G.next(f)) exc-=flow[e];
+
+          excess.set(v,exc);      
+
+          //putting the active nodes into the stack
+          int lev=level[v];
+          if ( exc > 0 && lev < n ) {
+            next.set(v,active[lev]);
+            active[lev]=v;
+          }
+        }
+
+
+        //the starting flow
+        OutEdgeIt e;
+        for(G.first(e,s); G.valid(e); G.next(e)) 
+        {
+          T rem=capacity[e]-flow[e];
+          if ( rem == 0 ) continue;
+          Node w=G.head(e);
+          if ( level[w] < n ) {   
+            if ( excess[w] == 0 && w!=t ) {
+              next.set(w,active[level[w]]);
+              active[level[w]]=w;
+            }
+            flow.set(e, capacity[e]); 
+            excess.set(w, excess[w]+rem);
+          }
+        }
+        
+        InEdgeIt f;
+        for(G.first(f,s); G.valid(f); G.next(f)) 
+        {
+          if ( flow[f] == 0 ) continue;
+          Node w=G.head(f);
+          if ( level[w] < n ) {   
+            if ( excess[w] == 0 && w!=t ) {
+              next.set(w,active[level[w]]);
+              active[level[w]]=w;
+            }
+            excess.set(w, excess[w]+flow[f]);
+            flow.set(f, 0); 
+          }
+        }
+      }
+
+
+
 
       /* 
@@ -339 +458 @@
             //unlacing ends
                 
-            //gapping starts
             if ( !G.valid(level_list[lev]) ) {
               
+               //gapping starts
               for (int i=lev; i!=k ; ) {
                 Node v=level_list[++i];
@@ -356 +475 @@
               k=b;
               //gapping ends
+            
             } else {
               
@@ -364 +484 @@
                 active[newlevel]=w;
                 if ( what_heur ) b=newlevel;
-                if ( k < newlevel ) ++k;
+                if ( k < newlevel ) ++k;      //now k=newlevel
                 Node first=level_list[newlevel];
                 if ( G.valid(first) ) left.set(first,w);
@@ -519 +639 @@
     }
 
+    
+    void reset_target (Node _t) {t=_t;}
+    void reset_source (Node _s) {s=_s;}
+   
+    template<typename _CapMap>   
+    void reset_cap (_CapMap _cap) {capacity=_cap;}
+
+    template<typename _FlowMap>   
+    void reset_cap (_FlowMap _flow, bool _constzero) {
+      flow=_flow;
+      constzero=_constzero;
+    }
+
+
 
   };