首先来认识一下网络流中最大流的问题
给定一个有向图G＝（V，E），把图中的边看做成管道，边权看做成每根管道能通过的最大流量（容量），给定源点s和汇点t，在源点有一个水源，在汇点有一个蓄水池，问s－t的最大水流量是多少
网络流图里,源点流出的量等于汇点流入的量,除源汇外的任何点,其流入量之和等于流出量之和 。
首先我们来看下面的图
s是源点,t是汇点
先这么想,先用dfs找出一条从s-t的路线,把他塞满,然后流量就是路径中容量最小的那条路的容量,然后把路径上的容量都剪去这个流量,再重新从s-t找可行路径,直到找不到为止
用这种思路看这个图
先走S-A-B-T,这样流量为100,并且没有可行路径了,即操作结束.
可是很明显,从S-A-T,S-B-T这两条路加起来的流量为200。所以这种思路是错的。
主要是过早的认为A-B的流量不为0
改进的思路：建立一个可以修改的网络，使得不合理的流可以被删掉
一种实现：对上次dfs时找到的流量路径上的边，添加一条“反向”边，反向边上的容量等于上次dfs时找到的该边上的流量，然后再利用“反向”的容量和其他边上剩余的容量寻找路径。
使用这种思路再求一次
第一次dfs后
第二次dfs（为了方便把容量为0的边删了）
这个时候已经没有可以走的边了，流量为200，dfs结束
为什么这种思路是正确的呢，网上有不少详细的证明。
Ford-Fulkerson算法
就是用这种思路做的
用dfs求增广路径，每次找到之后处理，直到找不到为止。
假设有n个定点，m条边，那么dfs的复杂度为n+m；
dfs运行c次
所以复杂度为c*(n+m);
但是dfs可能会运行很多次。
比如上面的图如果A-B中有条容量为1的边，那么运气不好的话，能执行200次dfs；
但实际上只要用2次就能找到
在每次增广的时候，选择从源到汇的具有最少边数的增广路径,即不是通过dfs寻找增广路径，而是通过bfs寻找增广路径。
这就是Edmonds-Karp 最短增广路算法
已经证明这种算法的复杂度上限为nm2 (n是点数， m是边数）；
现在来说几道题目
1-〉POJ 1273
题意:网络流的裸题，1为源点，n为汇点，给定每条边的容量，求最大流，用EK算法
| 1273 | Accepted | 1052K | 0MS | G++ | 1430B |
1 #include <stdio.h>
2 #include <iostream>
3 #include <stdlib.h>
4 #include <string.h>
5 #include <algorithm>
6 #include <vector>
7 #include <queue>
8 using namespace std;
9 #define N 300
10 #define INF 0x7fffffff
11 int Map[N][N];
12 int path[N];
13 //bool vis[N];
14 int n,m;
15 bool bfs(int s,int t)
16 {
17 int p;
18 queue<int> q;
19 memset(path,-1,sizeof(path));
20 //memset(vis,false,sizeof(vis));
21 path[s]=s;
22 // vis[s]=true;
23 q.push(s);
24 while(!q.empty())
25 {
26 p=q.front();
27 q.pop();
28 for(int i=1;i<=n;i++)
29 {
30 if(Map[p][i]>0&&path[i]==-1)
31 {
32 path[i]=p;
33 //vis[i]=true;
34 if(i==t)
35 return true;
36 q.push(i);
37 }
38 }
39 }
40 return false;
41 }
42 int EK(int s,int t)
43 {
44 int flow=0;
45 int d;
46 int i;
47 while(bfs(s,t))
48 {
49 d=INF;
50 for(i=t;i!=s;i=path[i])
51 {
52 d=min(d,Map[path[i]][i]);
53 }
54 for(i=t;i!=s;i=path[i])
55 {
56 Map[path[i]][i]-=d;
57 Map[i][path[i]]+=d;
58 }
59 flow+=d;
60 }
61 return flow;
62 }
63 int main()
64 {
65 while(scanf("%d %d",&m,&n)!=EOF)
66 {
67 memset(Map,0,sizeof(Map));
68 for(int i=1;i<=m;i++)
69 {
70 int from,to,flow;
71 scanf("%d %d %d",&from,&to,&flow);
72 Map[from][to]+=flow;
73 }
74 printf("%d\n",EK(1,n));
75 }
76
77 return 0;
78 }
2-〉POJ 3436
题意：一台电脑有P个部分，当电脑所有部分都被修好的时候，这台电脑才能出厂，有N台机器，每台机器每天最多能处理Q台电脑，机器只能接收与要求相符合的电脑，0表示这个部件不能有，1表示这个部件必须有，2表示这个部件可有可无，机器接受电脑部件之后会产出相应的产品，1表示这个部件有，0表示这个部件没有。求工厂一天能出厂多少台电脑。
思路：拆点建图，把接收形如222，000。。。（只要其中没有1），就把源点向这个点连一条容量为无穷大的边，把产出为111的，就把这个点向汇点连一条无穷大的边，我把编号为i的点，那么这个点拆成2*i-1和2*i两个点，2*i-1代表接受的，2*i代表产出的，这两个点之间连一条容量为第i台机器每天处理的电脑量的边，如果某台机器产出的点符合令一台机器接受的点，那就把那两个点也连上一条容量为无穷大的边。之后求最大流就可以了。
| 3436 | Accepted | 8648K | 32MS | G++ | 3338B |
1 #include <stdio.h>
2 #include <string.h>
3 #include <iostream>
4 #include <queue>
5 #include <stdlib.h>
6 #include <stack>
7 using namespace std;
8 #define N 1000
9 #define INF 0x7fffffff
10 int pre[N];
11 int map[N][N];
12 int mmap[N][N];
13 int P,n;
14 struct node
15 {
16 int rec[N];
17 int pro[N];
18 int flow;
19 };
20 node mac[N];
21 bool bfs(int s,int t)
22 {
23 int p;
24 stack<int> q;//不知道为什么stack能过queue就wa了。。
25 memset(pre,-1,sizeof(pre));
26 pre[s]=s;
27 q.push(s);
28 while(!q.empty())
29 {
30 p=q.top();
31 q.pop();
32 for(int i=0;i<=2*n+1;i++)
33 {
34 if(map[p][i]>0&&pre[i]==-1)
35 {
36 pre[i]=p;
37 if(i==t)
38 return true;
39 q.push(i);
40
41 }
42 }
43 }
44 return false;
45 }
46 void EK(int s,int t)
47 {
48 int flow=0;
49 int d,i;
50 int cnt=0;
51 while(bfs(s,t))
52 {
53 d=INF;
54 for(i=t;i!=s;i=pre[i])
55 d=min(d,map[pre[i]][i]);
56 for(i=t;i!=s;i=pre[i])
57 {
58 map[pre[i]][i]-=d;
59 if(!mmap[pre[i]][i])
60 {
61 if(pre[i]%2==0&&i&1&&i!=t&&pre[i]!=0)
62 {
63
64 cnt++;
65 }
66 }
67 map[i][pre[i]]+=d;
68 mmap[pre[i]][i]+=d;//每台机器之间流过的电脑数量
69 }
70
71 flow+=d;
72 }
73 printf("%d %d\n",flow,cnt);//最大流就是最多能产出的电脑，cnt就是几条机器之间的路径
74 for(int i=1;i<=2*n;i++)
75 for(int j=1;j<=2*n;j++)
76 {
77 if(mmap[i][j]&&i%2==0&&j%2!=0)
78 {
79 printf("%d %d %d\n",i/2,(j+1)/2,mmap[i][j]);
80 }
81 }
82 }
83 int main()
84 {
85 while(scanf("%d %d",&P,&n)!=EOF)
86 {
87 int cnt=1;
88 memset(map,0,sizeof(map));
89 memset(mmap,0,sizeof(mmap));
90 for(int i=1;i<=n;i++)
91 {
92 scanf("%d",&mac[i].flow);
93 for(int j=1;j<=P;j++)scanf("%d",&mac[i].rec[j]);
94 for(int j=1;j<=P;j++)scanf("%d",&mac[i].pro[j]);
95 map[cnt][cnt+1]=mac[i].flow;//拆点
96 cnt+=2;
97 }
98 bool flag;
99 for(int i=1;i<=n;i++)//处理源点和汇点
100 {
101 bool flag1=true;
102 bool flag2=true;
103 for(int j=1;j<=P;j++)
104 if(mac[i].pro[j]==0)flag2=false;
105 if(flag2)
106 map[i*2][2*n+1]=INF;
107 flag1=true;
108 flag2=true;
109 for(int j=1;j<=P;j++)
110 if(mac[i].rec[j]==1)flag1=false;
111 if(flag1)
112 map[0][2*i-1]=INF;
113 }
114 for(int i=1;i<=n;i++)//每台机器之间连边
115 {
116 for(int j=1;j<=n;j++)
117 {
118 if(i==j)
119 continue;
120 for(int k=1;k<=P;k++)
121 {
122 flag=true;
123 if((mac[i].pro[k]==1&&mac[j].rec[k]==0)||(mac[i].pro[k]==0&&mac[j].rec[k]==1))
124 {
125 flag=false;
126 break;
127 }
128 }
129 if(flag)
130 {
131 int u=i*2;
132 int v=j*2-1;
133 map[u][v]=INF;
134 }
135 }
136 }
137
138 /* for(int i=0;i<=2*n+1;i++)
139 {
140 for(int j=0;j<=2*n+1;j++)
141 {
142 printf("i:%d j:%d map[i][j]=%d\n",i,j,map[i][j]);
143 }
144 }*/
145 EK(0,2*n+1);
146 }
147 return 0;
148 }