最大流 Ford-Fulkerson算法

最大流问题：

　　管道网络中每条边的最大通过能力（容量）是有限的，实际流量不超过容量。

　　最大流问题(maximum flow problem)，一种组合最优化问题，就是要讨论如何充分利用装置的能力，使得运输的流量最大，以取得最好的效果。

Ford-Fulkerson算法：

（1）只利用满足f(e) < c(e)的e或者满足f(e) > 0的e对应的反向边rev(e),寻找一条s到t的路径。

（2）如果不存在满足条件的路径，则结束。否则，沿着该路径尽可能地增加流，放回第（1）步。

f为边的流量，c为边的容量，s为源点，t为汇点。

 Ford-Fulkerson算法主要是利用的反向点来算的。假设从A—>B可以流的流量是W，那么从B—>A就可以压回去W流量。

时间复杂度是O(F|E|)。

以HDU3549为例，这个就是标准的最大流问题。

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <vector>
#define INF 0x3f3f3f3f
using namespace std;
const int MAX = 1010;
struct Nod {
    int to, cap, rev;
};
vector<Nod> G[MAX];
bool vis[MAX];
void add_edge(int from, int to, int cap) {
    G[from].push_back((Nod){to,cap,(int)G[to].size()});
    G[to].push_back((Nod){from,0,(int)G[from].size()-1});
}
int dfs(int v, int t, int f) {
    if(v == t) return f;
    vis[v] = true;
    for(int i = 0; i < G[v].size(); i ++) {
        Nod &e = G[v][i];
        if(!vis[e.to] && e.cap > 0) {
            int d = dfs(e.to, t, min(f,e.cap));
            if(d > 0) {
                e.cap -= d;
                G[e.to][e.rev].cap += d;
                return d;
            }
        }
    }
    return 0;
}
int max_flow(int s, int t){
    int flow = 0;
    while(1) {
        memset(vis,0,sizeof(vis));
        int f = dfs(s, t, INF);
        if(f == 0) return flow;
        flow += f;
    }
}
int main() {
    int t, n, m;
    scanf("%d",&t);
    for(int k = 1; k <= t; k ++) {
        scanf("%d %d",&n, &m);
        while(m--) {
            int u, v, w;
            scanf("%d %d %d",&u, &v, &w);
            add_edge(u,v,w);
        }
        printf("Case %d: %d
",k,max_flow(1,n));
        for(int i = 1; i <= n; i ++) G[i].clear();
    }
    return 0;
}