(go) Maximum flow algorithm (EDMONDSKARP) of the network stream

The network flow has many algorithms, these days learned two kinds of, record the EK algorithm.

First, there are some definitions in the network flow:

V represents the collection of all the nodes in the entire graph.
E represents a collection of all the edges in the entire graph.
G = (v,e), which represents the entire graph.
s represents the source point of the network, and T represents the sink point for the network.
For each edge (U,V), there is a capacity of C (U,V) (c (u,v) >=0), and if C (u,v) = 0, then (u,v) does not exist in the network. Conversely, if there is no edge (u,v) in the original network, then C (u,v) =0.
For each edge (U,V), there is a flow f (u,v).

A simple example. The network can be imagined as a pipeline of water. The number to the right of the parentheses indicates the capacity of the pipe C, and the number on the left indicates the current flow F of the pipe.

Three properties of the network stream:

1. Capacity limit: F[u,v]<=c[u,v]
2, anti-symmetry: f[u,v] =-F[v,u]
3. Flow balance: For any node that is not a source point or a sink point, the traffic flowing into the node is equal to the traffic flowing out of the node.
As long as these three properties are met, it is a legitimate network flow.

The maximum flow problem is to find the maximum flow of the source S to the meeting point T in the case of satisfying the nature of the network flow.

To find the maximum flow of a network stream there are many algorithms here first introduce the Augmented path algorithm (EK)

Before learning the algorithm, first look at the definition of several diagrams involved in this algorithm:

* * Network of residual quantity

In order to make the algorithm more convenient, a residual network is usually defined according to the original network. where R (U,V) is the capacity of the residual network.
R (u,v) = C (u,v) –f (u,v)
In layman's words: it is for a certain edge (also called arc), but also how much flow through.
Gf Residue Network, Ef represents the edge set of a residual network.

This is a residual network of the above figure. Residual network (if the capacity of an edge in the network is 0, the edge is not considered to be in the residual network.)

R (S,V1) = 0, so it is not drawn. Another example: R (v1,s) = C (v1,s) –f (v1,s) = 0– (-f (s,v1)) = f (s,v1) = 4.

Where a side like (V1,s) is called a back arc, it means that the flow from V1 to S can also be increased by 4 units.

But from V1 to S is not the same direction as the arc in the original network? Obviously, "from V1 to S can also increase 4 unit flow" This information is meaningless. So, is it necessary to build these back arcs?

Obviously, the drawing in the 1th figure is not a maximum flow.

However, if we add 2 to the flow of the arc that passes through the path of V1---v2---------------

Notice that this path passes through a back arc: (V2,V1).

If you do not set up a back arc, the algorithm cannot find the path.

* * In essence, a back arc provides the possibility for the algorithm to correct its own errors, which allows the algorithm to cancel the behavior of the previous error (letting the 2-unit stream flow from V1 to v2)

Note that the back arc is conceptually, and there is no difference between the back arc and the forward arc in the program.

* * Augmented Road

Augmented path definition: A path from S to T in the residual network, with any arc (U,V), has r[u,v]>0.

The green one is an augmented road.

See so many concepts believe that we have the augmented path algorithm has a general idea of it.

* * Augmented path algorithm

Augmented path algorithm: each time using BFS to find a shortest augmented path, and then along this path to modify the traffic value (actually modified is the Benquan of the residual network). When there is no augmented path, the algorithm stops, and the flow at this time is the maximum flow.

* * Efficiency of the augmented path algorithm

Set n = | v|, M = | e|

Each augmentation is a BFS, the efficiency is O (m), and in the worst case (n-2 augmentation). (that is, except for the source and sink points are not connected, all points are only and S and T connect)

Therefore, the total time complexity is O (m*n), so in the sparse graph is still relatively high efficiency.

Hdoj 1532 is one that can be used as a template topic practiced hand.

Template code:

[CPP]View Plaincopyprint?

2. #include <cstdio>
4. #include <cstring>
6. #include <iostream>
8. #include <string>
10. #include <algorithm>
12. #include <map>
14. #include <vector>
16. Using namespace std;
18. const int N = 1100;
20. const int INF = 0x3f3f3f3f;
24. struct Node
26. {
28. int to; //end point
30. int cap; //Capacity
32. int rev; //Reverse side
34. };
38. Vector<node> V[n];
40. BOOL Used[n];
44. void Add_node (int from,int. to,int cap) //heavy edge condition does not affect
46. {
48. V[from].push_back (Node) {to,cap,v[to].size ()});
50. V[to].push_back (Node) {from,0,v[from].size ()-1});
52. }
56. int DFS (int s,int T,int f)
58. {
60. if (s==t)
62. return F;
64. Used[s]=true;
66. For (int i=0;i<v[s].size (); i++)
68. {
70. Node &tmp = V[s][i]; //Note
72. if (used[tmp.to]==false && tmp.cap>0)
74. {
76. int D=dfs (tmp.to,t,min (F,tmp.cap));
78. if (d>0)
80. {
82. Tmp.cap-=d;
84. V[tmp.to][tmp.rev].cap+=d;
86. return D;
88. }
90. }
92. }
94. return 0;
96. }
100. int Max_flow (int s,int t)
102. {
104. int flow=0;
106. for (;;) {  
108. memset (used,false,sizeof (used));
110. int F=dfs (s,t,inf);
112. if (f==0)
114. return flow;
116. Flow+=f;
118. }
120. }
122. int main ()
124. {
126. int n,m;
128. while (~scanf ("%d%d", &n,&m))
130. {
132. memset (v,0,sizeof (v));
134. For (int i=0;i<n;i++)
136. {
138. int x, y, Z;
140. scanf ("%d%d%d", &x,&y,&z);
142. Add_node (x, y, z);
144. }
146. printf ("%d\n", Max_flow (1,m));
148. }
150. }

(go) Maximum flow algorithm (EDMONDSKARP) of the network stream