算法设计 最大网络流

算法设计 最大网络流

最大网络流问题是图论中的经典问题，以前只是学习了Ford-Fulkerson方法，趁现在
比较“轻闲”把网络流的Push-relabel方法也学习一下。我们知道利用最短路径的Ford-Fulkerson方法实现算法，其
时间复杂度可以达到O(VE^2)，而Push-relabel方法的算法实现（relabel-to-front）的复杂度可以达到O(V^3).

先说明一下基本概念：
c(u,v)代表网络管道(u,v)之间的流量限制，其值总是大于零的(c(u,v)=0 <=>no edge exist between u and v)
f(u,v)代表网络管道(u,v)之间的实际流量，当然不能超过c(u,v)的限制，且f(u,v)=-f(v,u)。
residual网络代表所有的剩余流组成的网络且该网络上的限制cf(u,v)=c(u,v)-f(u,v)（c，f分别是原网络的参数）
该网络可以表示为G = (V,Ef)。

Ford-Fulkerson方法的思想是每次都找到一个增广路径，然后填满该增广路径上的所有瓶颈流量。不断找到增广路径直到
没有为止，这样就可以找到一种最大流方案。该方法是从全局考虑每个路径的能力，让每一个路径都尽力而为，而Push-relabel
方法则将流量调整的权利下放到每一个节点，通过节点讲多余的流量挤出网络从而是网络的流量达到最大。那么怎么样某
一个节点能够讲他多余出来的流挤到下一个节点呢，就是该节点的势比较高，就是高度比较高，这里面有一个
Admissible edge（(u,v)属于Ef并且h(u)=h(v)+1（h就是高度））的概念，就是能够通过这个edge将多余流量挤出去的管道。
通过反复的挤出流最终达到流量的最大。具体参考（算法导论），导论中先讲了Push Relabel 方法，然后介绍了一个基于该方法
的relabel-to-front算法。期中discharge方法相当于将自己多余的流挤给其他人，而总的relabel-to-front方法就是不停的调整
直到没有人可以将自己多余的流挤个其他人为止，这里在push的时候会因为管道能力的问题将多余流量扔掉，最后到达T的时候的
流量就是最后的最大流。

下面是relabel-to-front算法的具体实现
注意要使用g++编译器，vc需要将变量声明修改一下

1. #include <iostream>
2. #include <climits>
4. using namespace std;
6. #define BUF 100
8. int f[BUF][BUF];
9. int c[BUF][BUF];
11. struct Edge{
12.     int v;
13.     Edge *next;
14. };
16. struct Node{
17.     int h;
18.     int ef;
19.     Edge *firste;
20. };
21.     
22. Node graph[BUF];
23. Edge *current[BUF];
25. struct List{
26.     int n;
27.     List *next;
28. };
30. List *L;
32. int N;
34. int S,T;
35. /*
36. sample input:
37. 6 1 6 10
38. 1 2 16
39. 1 4 13
40. 2 4 10
41. 4 2 4
42. 2 3 12
43. 3 4 9
44. 4 5 14
45. 5 3 7
46. 3 6 20
47. 5 6 4
48. the first line represent |V|=6,S=1,T=6,|E|=10.
49. then the next ten lines represent 10 edges of the graph.
50. */
51. void init_graph()
52. {
53.     int eN;
54.     
55.     scanf("%d%d%d%d",&N,&S,&T,&eN);
57.     for(int i=1;i<N;i++)
58.         graph[i].firste = NULL;
59.         
60.     for(int i=1;i<=eN;i++){
61.         
62.         int s,e;
63.         
64.         scanf("%d%d",&s,&e);
65.         
66.         if(c[e][s]==0){
67.             Edge *e1 = new Edge();
68.             Edge *e2 = new Edge();
69.         
70.             e1->v = s,e2->v = e;
71.         
72.             e1->next = graph[e].firste;
73.             e2->next = graph[s].firste;
74.             
75.             graph[e].firste = e1;
76.             graph[s].firste = e2;
77.         }
78.         
79.         scanf("%d",&c[s][e]);
80.     }
81. }
83. //to print the debug information 
84. void print()
85. {
86.     for(int i=1;i<=N;i++){
87.         for(int j=1;j<=N;j++)
88.             printf("%d ",c[i][j]);      
89.         printf("/n");
90.     }
91.     printf("/n");
92.     for(int i=1;i<=N;i++){
93.         for(int j=1;j<=N;j++)
94.             printf("%d ",f[i][j]);      
95.         printf("/n");
96.     }
97.     printf("/n");
98.     List *p = L->next;
99.     while(p!=NULL){
100.         printf("%d ",p->n);
101.         p = p->next;
102.     }
103.     printf("/n");
104.     for(int i=1;i<=N;i++)
105.         printf("%d ",graph[i].ef);
106.     printf("/n/n");
107. }
109. void init_preflow()
110. {
111.     for(int i=0;i<N;i++){
112.         graph[i].h = 0;
113.         graph[i].ef = 0;
114.     }
115.     
116.     fill_n(&f[0][0],BUF*BUF,0);
117.     
118.     graph[S].h = N;
119.     
120.     for(Edge *p=graph[S].firste;p!=NULL;p=p->next){ 
121.         f[S][p->v] = c[S][p->v];
122.         f[p->v][S] = -1*c[S][p->v];
123.         graph[p->v].ef = c[S][p->v];
124.         graph[S].ef -= c[S][p->v];
125.     }
126. }
128. void init_list()
129. {
130.     L = new List();
132.     List *p = L;
133.     
134.     for(int i=1;i<=N;i++)
135.         if(i!=S&&i!=T){
136.             p->next = new List();
137.             p->next->n = i;
138.             p = p->next;
139.         }
140.     p->next = NULL;
141. }
142.             
143. // the next four functions are the core of the relabel to front algorithm.
144.     
145. void push(int u,int v)
146. {
147.     if(graph[u].ef>0&&graph[u].h==(graph[v].h+1)){
148.         int df = c[u][v]-f[u][v];
149.         df = min(df,graph[u].ef);
150.         f[u][v] += df;
151.         f[v][u] = -1*f[u][v];
152.         graph[u].ef -= df;
153.         graph[v].ef += df;
154.     }
155. }
157. void relabel(int u)
158. {
159.     if(graph[u].ef>0){
160.         
161.         int low = INT_MAX;
162.         bool have = false;
163.         
164.         for(Edge *p=graph[u].firste;p!=NULL;p=p->next)
165.             if(c[u][p->v]-f[u][p->v]>0&&graph[u].h<=graph[p->v].h){                 
166.                 low = min(low,graph[p->v].h);
167.                 have = true;
168.             }
170.         if(have)
171.             graph[u].h = low+1;
172.     }
173. }
174.             
175. void discharge(int u)
176. {
177.     while(graph[u].ef>0){
178.         
179.         Edge *pv = current[u];
180.         
181.         if(pv==NULL){
182.             relabel(u);
183.             current[u] = graph[u].firste;
184.         }else if(c[u][pv->v]-f[u][pv->v]>0&&graph[u].h==(graph[pv->v].h+1)){
185.             push(u,pv->v);
186.         }else {
187.             current[u] = pv->next;
188.         }
189.     }
190. }
191.         
192. void relabel_front()
193. {
194.     init_preflow();
195.     
196.     init_list();
197.     
198.     for(int i=1;i<=N;i++)
199.         if(i!=S&&i!=T)
200.             current[i] = graph[i].firste;
201.     
202.     List *q = L;
203.     List *p = L->next;
204.     
205.     while(p!=NULL){
206.         
207.         int oh = graph[p->n].h;
209.         discharge(p->n);
210.         
211.         if(graph[p->n].h>oh){
212.             
213.             q->next = p->next;
214.             q = L;
215.             p->next = q->next;
216.             q->next = p;
217.         }
218.         
219.         p = p->next;
220.         q = q->next;
222. //      print();
223.     }
224. }
225.             
226. int main()
227. {
228.     freopen("rf1.in","r",stdin);
229.     freopen("rf.out","w",stdout);
230.     
231.     init_graph();
232.     
233.     relabel_front();
234.     
235.     printf("%d/n",-1*graph[S].ef);
236.     
237.     return 0;
238. }