网络流——poj1273（入门）

题目链接：排水沟

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

【EK解法】

#include <algorithm>  
#include <queue>  
#include <string.h>  
using namespace std;  
int const MAX = 1005;  
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 = 0;  
    while(!q.empty())   q.pop();  
    memset(f, 0, sizeof(f));  
    while(1){  
        memset(a, 0, sizeof(a));  
        a[s] = inf;//将起始点的最小残余量设为最大  
        q.push(s);  
        while(!q.empty()){//bfs找到一条最短路，这里的边不代表距离，可以看作每两个点都是单位距离的  
            int u;  
            u = q.front();  
            q.pop();  
            for(int v = 1; 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, 0, sizeof(c));  
        memset(p, 0, sizeof(p));  
        for(int i = 1; i <= n; i++){  
            int u, v, w;  
            scanf("%d %d %d", &u, &v, &w);  
            c[u][v] += w;  
        }  
        printf("%d
", bfs(1, m));  
    }  
    return 0;  
}

【Dinic解法】

#include <cstdio>
#include <string.h>
#include <queue>
using namespace std;
int const inf = 0x3f3f3f3f;
int const MAX = 205;
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, -1, sizeof(dep));
    dep[s] = 0;
    q.push(s);
    while(!q.empty()){
        int u = q.front();
        q.pop();
        for(int v = 1; v <= m; v++){
            if(c[u][v] > 0 && dep[v] == -1){//如果可以到达且还没有访问，可以到达的条件是剩余容量大于0，没有访问的条件是当前层数还未知
                dep[v] = dep[u] + 1;
                q.push(v);
            }
        }
    }
    return dep[t] != -1;
}

int dfs(int u, int mi, int t)//查找路径上的最小流量
{
    if(u == t)
        return mi;
    int tmp;
    for(int v = 1; v <= m; v++){
        if(c[u][v] > 0 && dep[v] == dep[u] + 1  && (tmp = dfs(v, min(mi, c[u][v]), t))){
            c[u][v] -= tmp;
            c[v][u] += tmp;
            return tmp;
        }
    }
    return 0;
}

int dinic()
{
    int ans = 0, tmp;
    while(bfs(1, m)){
        while(1){
            tmp = dfs(1, inf, m);
            if(tmp == 0)
                break;
            ans += tmp;
        }
    }
    return ans;
}

int main()
{
    while(~scanf("%d %d", &n, &m)){
        memset(c, 0, sizeof(c));
        int u, v, w;
        while(n--){
            scanf("%d %d %d", &u, &v, &w);
            c[u][v] += w;
        }
        printf("%d
", dinic());
    }
    return 0;
}