网络流小结 - hdu 1532

网络流问题在已经知道每条边的容量以及流量的情况下，求出从起点到终点可以运送的最大流量。

这里面需要注意的有：容量限制，斜对称性和流量平衡的3个条件。

容量限制即保证每个边流过的流量小于每个边的容量 ,即f(u,v) < c(u,v);

斜对称性即为：f(u,v) = -f(v,u);

流量平衡即为：除了起点和终点外每个点都需要流进的流量等于流出的流量，同时起点流出的流量要等于终点流入的流量。

我们在解决问题的时候，用到的增广路算法就是需要不断地增加流量，知道无法增加流量为止。

同时需要构建一个残余网络图，这在下面的代码中我会介绍。

增光路算法基于一个事实：残余网络任何一条从s到t的有向道路都对应原图中的一条增广路———只要求出该道路中所有所有残量的最小值d，

把对应的所有边的流量增加d即可，这个过程称为增广。

增广前的流量满足我所介绍的3个条件，很显然我们增广后的流量仍然满足以上的3个条件。

这里我介绍一下增广路定理：如果残余网络不存在增广路，则当前流就是最大流。

因为要找任意路径，做一简单的方法就是dfs，但是有时候会很慢。对于杭电1532 Drainage Ditches这道模板题我首先给出dfs方法

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
const int N = 205;
const int INF = 0x3f3f3f3f;

struct Node
{
    int to; //终点
    int cap; //容量
    int rev; //反向边的编号
};

vector <Node> v[N];
bool used[N];

void add_Node(int from,int to,int cap)
{
    v[from].push_back((Node){to,cap,v[to].size()});
    v[to].push_back((Node){from,0,v[from].size()-1}); //因为已经放进去了所以要减一。
}

int dfs(int s,int t,int f)
{
    if(s == t) return f;
    used[s] = true;
    for(int i = 0; i < v[s].size(); i++)
    {
        Node& temp = v[s][i];
        if(!used[temp.to] && temp.cap > 0)
        {
            int d = dfs(temp.to,t,min(f,temp.cap));  //这里就是前面我所说的找出增广路上所有残量的最小值
            if(d > 0)
            {
                temp.cap -= d;
                v[temp.to][temp.rev].cap += d; //要满足上面的3个原理，因为需要对于已经找到的增广路上的边的最大流量进行调整
                return d;
            }
        }
    }
    return 0; // 这一定不能省略，因为有可能找不到增广路，这时候就要返回0了。
}

int max_flow(int s,int t)
{
    int flow = 0;
    while(1)
    {
        memset(used,false,sizeof(used));
        int f = dfs(s,t,INF);
        if(f == 0)       //如果找不到增广路那么当前流就是最大流，这时就可以得到结果了。
            return flow;
        flow += f;
    }
}

int main()
{
    int n,m;
    while(scanf("%d%d",&n,&m) != EOF)
    {
        memset(v,0,sizeof(v));
        for(int i = 0; i < n; i++)
        {
            int from,to,cap;
            scanf("%d%d%d",&from,&to,&cap);
            add_Node(from,to,cap);
        }
        printf("%d\n",max_flow(1,m));
    }
    return 0;
}

还有一种方法就是bfs方法，这个算法可以对付一些不是很刁钻的网络流题目，这就是Edmonds-Karp算法，这里我同样以刚才的题目贴出bfs算法。

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;
const int maxn = 205;
const int INF = 0x3f3f3f3f;

struct Edge
{
    int from,to,cap,flow;
    Edge(int u, int v, int c, int f):from(u),to(v),cap(c),flow(f) {}
};

struct EK
{

    int n,m;
    vector <Edge> edges;
    vector <int> G[maxn];
    bool done[maxn];
    int a[maxn];
    int p[maxn];

    void init(int n)
    {
        this->n = n;
        for(int i = 0; i <= n; i++)
            G[i].clear();
        edges.clear();
    }

    void AddEdge(int from, int to, int cap)
    {
        edges.push_back(Edge(from,to,cap,0));
        edges.push_back(Edge(from,to,0,0)); //·´Ïò»¡
        m = edges.size();
        G[from].push_back(m-2);
        G[to].push_back(m-1);
    }

    int Maxflow(int s,int t)
    {
        int flow = 0;
        for(;;)
        {
            memset(a,0,sizeof(a));
            queue <int> Q;
            Q.push(s);
            a[s] = INF;
            while(!Q.empty())
            {
                int x = Q.front(); Q.pop();
                for(int i = 0; i < G[x].size(); i++)
                {
                    Edge& e = edges[G[x][i]];
                    if(!a[e.to] && e.cap > e.flow)
                    {
                        p[e.to] = G[x][i];  //p数组用来存储增广路径。
                        a[e.to] = min(a[x],e.cap - e.flow);
                        Q.push(e.to);
                    }
                }
                if(a[t]) break;
            }
            if(!a[t]) break;
            for(int u = t; u != s; u = edges[p[u]].from)
            {
                edges[p[u]].flow += a[t];     //通过异或运算得到反向边。
                edges[p[u]^1].flow -= a[t];
            }
            flow += a[t];
        }
        return flow;
    }

}result;

int main()
{
    int m,n;
    while(scanf("%d%d",&m,&n) != EOF)
    {
        result.init(n);
        int u,v,cap;
        for(int i = 0; i < m; i++)
        {
            scanf("%d%d%d",&u,&v,&cap);
            result.AddEdge(u,v,cap);
        }
        printf("%d\n",result.Maxflow(1,n));
    }
    return 0;
}