看见了一篇非常不错的博文  http://www.cnblogs.com/Booble/archive/2011/03/04/1970453.html

1 容量限制
2 流量守恒
3 斜对称性  x向y流了F的流 y就向x流了-F的流

残留网络 = 容量网络 - 流量网络
这个等式是始终成立的 残留值当流量值为负时甚至会大于容量值
流量值为什么会为负?有正必有负,记住斜对称性!

最短路径增广算法

增广路方法是很多网络流算法的基础 一般都在残留网络中实现
其思路是每次找出一条从源到汇的能够增加流的路径 调整流值和残留网络 不断调整直到没有增广路为止
FF方法的基础是增广路定理: 网络达到最大流当且仅当残留网络中没有增广路

EK算法就是不断的找最短路 找的方法就是每次找一条边数最少的增广 也就是最短路径增广

2.如何找到一条增广路?
先明确什么是增广路 增广路是这样一条从s到t的路径 路径上每条边残留容量都为正
把残留容量为正的边设为可行的边 那么我们就可以用简单的BFS得到边数最少的增广路

3.如何增广?
BFS得到增广路之后 这条增广路能够增广的流值 是路径上最小残留容量边决定的
把这个最小残留容量MinCap值加到最大流值Flow上 同时路径上每条边的残留容量值减去MinCap
最后 路径上每条边的反向边残留容量值要加上MinCap

上面还遗留了一个反向边的问题: 为什么增广路径上每条边的反向边残留容量值要加上MinCap?
因为斜对称性! 由于残留网络=容量网络-流量网络
容量网络不改变的情况下
由于增广好比给增广路上通了一条流 路径说所有边流量加MinCap
流量网络中路径上边的流量加MinCap 反向边流量减去MinCap
相对应的残留网络就发生相反的改变
这样我们就完成了EK算法 具体实现可以用邻接表存图 也可以用邻接矩阵存图
邻接表存图 由于流量同时存在于边与反向边 为了方便求取反向边 建图把一对互为反向边的边建在一起

1.任意一个流都小于等于任意一个割
2.构造出一个流等于一个割
3.最大流等于最小割

 

struct edge
{
    int from, to, cap, flow;//分别是起点，终点，容量，流量
    edge(int u, int v, int c, int f):from(u), to(v), cap(c), flow(f){}
};

int n, m;//n为点数，m为边数
vector<edge>e;//保存所有边的信息
vector<int>G[maxn];//邻接表，G[i][j]保存节点i的第j条边在e数组里面的编号
int a[maxn];//每个点目前流经的水量
int p[maxn];//p[i]从原点s到终点t的节点i的前一条边的编号

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

void addedge(int u, int v, int c)
{
    e.push_back(edge(u, v, c, 0));//正向边
    e.push_back(edge(v, u, 0, 0));//反向边，容量为0
    m = e.size();
    G[u].push_back(m - 2);
    G[v].push_back(m - 1);
}

int Maxflow(int s, int t)//起点为s，终点为t
{
    int flow = 0;
    for(;;)
    {
        memset(a, 0, sizeof(a));//从原点s开始放水，最初每个点的水量都为0
        queue<int>Q;//BFS拓展队列
        Q.push(s);
        a[s] = INF;//原点的水设置成INF
        while(!Q.empty())
        {
            int x = Q.front();//取出目前水流到的节点
            Q.pop();
            for(int i = 0; i < G[x].size(); i++)//所有邻接节点
            {
                edge& now = e[G[x][i]];
                if(!a[now.to] && now.cap > now.flow)
                    //a[i]为0表示i点还未流到
                    //now.cap > now.flow 说明这条路还没流满
                    //同时满足这两个条件，水流可以流过这条路
                {
                    p[now.to] = G[x][i];//反向记录路径
                    a[now.to] = min(a[x], now.cap - now.flow);
                    //流到下一点的水量为上一点的水量或者路径上还可以流的最大流量，这两者取最小值
                    Q.push(now.to);//将下一个节点入队列
                }
            }
            if(a[t])break;//如果已经流到了终点t，退出本次找增广路
        }
        if(!a[t])break;//如果所有路都已经试过，水不能流到终点，说明已经没有增广路，已经是最大流
        for(int u = t; u != s; u = e[p[u]].from)//反向记录路径
        {
            e[p[u]].flow += a[t];//路径上所有正向边的流量增加流到终点的流量
            e[p[u]^1].flow -= a[t];//路径上所有反向边的流量减少流到终点的流量
        }
        flow += a[t];//最大流加上本次流到终点的流量
    }
    return flow;
}

POJ 1273

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<string>
#include<queue>
#include<algorithm>
#include<map>
using namespace std;

const int INF = 1e9 + 10;
int n,m,x,y,z,ans,l,r,minn;
int g[500][500];
int q[500],pre[500];
bool p[500],flag;

int main()
{
    while(~scanf("%d%d",&m,&n))
    {
        memset(g,0,sizeof(g));
        for(int i = 1;i <= m; ++i)
        {
            scanf("%d%d%d",&x,&y,&z);
            g[x][y] += z;
        }
        ans = 0;
        while(1)
        {
            l = 1; r = 1;
            memset(p,0,sizeof(p));
            p[1] = 1;
            q[1] = 1;  //p标记是否被访问过
            flag = 0;
            while(l <= r)
            {
                for(int i = 1;i <= n; ++i)
                    if(!p[i] && g[q[l]][i] > 0)
                    {
                        q[++r] = i;
                        p[i] = 1;
                        pre[r] = l;  //记录上一个节点
                        if(q[r] == n)
                        {
                            flag = 1;
                            break;
                        }
                    }
                if(flag) break;
                l++;
            }
            if(!flag) break;
            minn = INF;
            for(int i = r; q[i] != 1; i = pre[i])
                minn = min(minn,g[q[pre[i]]][q[i]]);
            for(int i = r; q[i] != 1; i = pre[i])
            {
                g[q[pre[i]]][q[i]] -= minn;   //斜对称性
                g[q[i]][q[pre[i]]] += minn;
            }
            ans += minn;
        }
        printf("%d\n",ans);
    }
    return 0;
}