网络流——poj1273（入门）

题目链接：排水沟

题意：现有n个排水沟和m个点（其中1是源点，m是汇点），给定n个排水沟所连接的点，求从源点到汇点的最大流量。

【EK解法】

 #include <algorithm>
 #include <queue>
 #include <string.h>
 using namespace std;
 int const MAX = ;
 int const inf = 0x3f3f3f3f;
 int c[MAX][MAX];//c[u][v]保存容量
 int f[MAX][MAX];//f[u][v]保存当前流量
 int a[MAX];// a数组在每趟bfs中找到最小路径中最小残余流量的，a数组使个递推数组，a[v]的意思是从源点s到点v的最小残余流量
 int p[MAX];//保存前一个点
 int n, m;
 int bfs(int s, int t)
 {
     queue<int> q;
     int flow = ;
     while(!q.empty())   q.pop();
     memset(f, , sizeof(f));
     while(){
         memset(a, , sizeof(a));
         a[s] = inf;//将起始点的最小残余量设为最大
         q.push(s);
         while(!q.empty()){//bfs找到一条最短路，这里的边不代表距离，可以看作每两个点都是单位距离的
             int u;
             u = q.front();
             q.pop();
             for(int v = ; v <= m; v++){//枚举所有点v <u,v>
                 if(!a[v] && c[u][v] > f[u][v]){//a[]可以代替vis[]，来判断这个点是否已经遍历过，后面那个条件更是起了关键作用，很巧妙
                     p[v] = u;
                     q.push(v);
                     a[v] = min(a[u], c[u][v] - f[u][v]);//递推
                 }
             }
         }
         if(!a[t])   break;//直到最小残余流量为0时，退出
         for(int u = t; u != s; u = p[u]){
             f[p[u]][u] += a[t];
             f[u][p[u]] -= a[t];
         }
         flow += a[t];
     }
     return flow;
 }  
 
 int main()
 {
     while(~scanf("%d %d", &n, &m)){
         memset(c, , sizeof(c));
         memset(p, , sizeof(p));
         for(int i = ; i <= n; i++){
             int u, v, w;
             scanf("%d %d %d", &u, &v, &w);
             c[u][v] += w;
         }
         printf("%d\n", bfs(, m));
     }
     return ;
 }

EK解法

【Dinic解法】

 #include <cstdio>
 #include <string.h>
 #include <queue>
 using namespace std;
 int const inf = 0x3f3f3f3f;
 int const MAX = ;
 int n, m;
 int c[MAX][MAX], dep[MAX];//dep[MAX]代表当前层数
 
 int bfs(int s, int t)//重新建图，按层次建图
 {
     queue<int> q;
     while(!q.empty())
         q.pop();
     memset(dep, -, sizeof(dep));
     dep[s] = ;
     q.push(s);
     while(!q.empty()){
         int u = q.front();
         q.pop();
         for(int v = ; v <= m; v++){
             if(c[u][v] >  && dep[v] == -){//如果可以到达且还没有访问，可以到达的条件是剩余容量大于0，没有访问的条件是当前层数还未知
                 dep[v] = dep[u] + ;
                 q.push(v);
             }
         }
     }
     return dep[t] != -;
 }
 
 int dfs(int u, int mi, int t)//查找路径上的最小流量
 {
     if(u == t)
         return mi;
     int tmp;
     for(int v = ; v <= m; v++){
         if(c[u][v] >  && dep[v] == dep[u] +   && (tmp = dfs(v, min(mi, c[u][v]), t))){
             c[u][v] -= tmp;
             c[v][u] += tmp;
             return tmp;
         }
     }
     return ;
 }
 
 int dinic()
 {
     int ans = , tmp;
     while(bfs(, m)){
         while(){
             tmp = dfs(, inf, m);
             if(tmp == )
                 break;
             ans += tmp;
         }
     }
     return ans;
 }
 
 int main()
 {
     while(~scanf("%d %d", &n, &m)){
         memset(c, , sizeof(c));
         int u, v, w;
         while(n--){
             scanf("%d %d %d", &u, &v, &w);
             c[u][v] += w;
         }
         printf("%d\n", dinic());
     }
     return ;
 }

Dinic解法