最大流的Ford-Fulkerson 标号法

最大流标号法：

https://wenku.baidu.com/view/5977dc6fa45177232f60a266.html

最大流的标号法总的来说就是不断地在图中找增广路径。增广路径就是一条从源点到汇点的路径，所有前向边都是非饱和边，反向边都是非零边

http://blog.csdn.net/fengchaokobe/article/details/7584781

在这节中，我将描述一种构造所有增广路径算法的方法，这种方法是由Ford and Fulkerson在1956年发明的。
       增广路径是找出在残留网络中从源点到汇点的有向路径。增广路径的残留容量是路径中任意边所形成的最小残留容量。显然，我们可以沿着增广路径从源点到汇点发送额外的流。

       假如有这么一条路，这条路从源点开始一直一段一段的连到了汇点，并且，这条路上的每一段都满足流量 < 容量。那么，我们一定能找到这条路上的每一段的(容量-流量)的值当中的最小值delta。我们把这条路上每一段的流量都加上这个delta，一定可以保证这个流依然是可行流。这样我们就得到了一个更大的流，他的流量是之前的流量+delta，而这条路就叫做增广路径。

       所有的增广路径算法的构造是基于增广路径定理的：

       定理一(增广路径定理)：流x是最大流当且仅当这个残留网络不包含其他增广路经。

       由这个定理我们得到一种找到最大流的方法。这种方法通过在所有路径中不断地找出增广路径和增广流，直到网络中不在包含这样的路径。我们要讨论的一些算法，它们所不不同的只是寻找增广路径的方法。

       我们认为最大流问题基于以下假设：

              假设一：这个流网络是一个有向网。

              假设二：网络中的所有容量都是非负整数。
              附注：这个假设对于某些算法不是必须的，这些算法的复杂边界涉及到数据的完整性。

              假设三：这个问题有一个最佳解决方案，且这个方案是有界的。
              附注：这个特定的假设意味着从源点到汇点是有容量限制的路径。

              假设四：这个网中不包含平行的弧。
              附注：这个假设的规定不失一般性，因为我们可以总结出所有平行弧的容量。

两个while循环，内部的while循环就是在当前的残余网络种找增广路径，外部的while就是在每找到一条增广路径后，就更新图，然后继续找

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
#define maxn 10010
#define INF 0xfffffff
struct ArcType
{
    int c,f;//容量、流量
};
ArcType edge[maxn][maxn];
int n,m;//顶点数、弧数
int flag[maxn];//顶点状态：-1——未标号；0——已标号未检查；1——已标号已检查
int pre[maxn];//标号的第一个分量：指明标号从哪个顶点而来，以便找出可改进量
int alpha[maxn];//标号的第二个分量：可改进量α
int que[maxn];//相当于BFS中的队列
int v;//队列头元素
int qs,qe;//队首队尾的位置
int i,j;
void ford()//标号法求网络最大流
{
    while(1)//标号，直到不存在可改进路
    {
        memset(flag,-1,sizeof(flag));
        memset(pre,-1,sizeof(pre));
        memset(alpha,-1,sizeof(alpha));
        flag[0]=0;
        pre[0]=0;
        alpha[0]=INF;
        qs=qe=0;
        que[qe]=0;//源点0入队列
        ++qe;
        while(qs<qe&&flag[n-1]==-1)    //不断找增广路径，类似与Dinic算法，其实这里是边BFS分层边找增广路径，而Dinic是先BFS分层在找增广路径
        {
            v=que[qs];//取队首元素
            ++qs;
            for(i=0; i<n; ++i)//检查顶点v的正向和反向邻接点
                if(flag[i]==-1)
                {
                    if(edge[v][i].c<INF&&edge[v][i].f<edge[v][i].c)//正向且未满
                    {
                        flag[i]=0;//给顶点i标号，但此时未检查
                        pre[i]=v;
                        alpha[i]=min(alpha[v],edge[v][i].c-edge[v][i].f);  //alpha[i]表示v处流过来的流量，edge[v][i].c-edge[v][i].f表示v->i可以通过的流量
                        que[qe]=i;//顶点i入队
                        ++qe;
                    }
                    else if(edge[i][v].c<INF&&edge[i][v].f>0)//反向且有流量，这里的反向是相对于BFS的顺序来的，对于所有没有被遍历的点i，BFS所在层都比现在的点v低，那么i->v就是反向边了
                    {
                        flag[i]=0;
                        pre[i]=-v;
                        alpha[i]=min(alpha[v],edge[i][v].f);
                        que[qe]=i;
                        ++qe;
                    }
                }
            flag[v]=1;//标记顶点i已经检查
        }
        if(flag[n-1]==-1||alpha[n-1]==0) break;//汇点无标号或汇点的调整量为0
        int k1=n-1,k2=abs(pre[k1]);
        int a=alpha[n-1];//可改进量α
        while(1)    //将这条增广路径上的边都减去流到n-1的流量
        {
            if(edge[k2][k1].f<INF) edge[k2][k1].f+=a;//正向，加流量
            else edge[k1][k2].f-=a;//反向，退流量
            if(k2==0) break;//一直调整到源点0
            k1=k2;
            k2=abs(pre[k2]);
        }
    }
    int maxflow=0;//最大流量
    for(i=0; i<n; ++i)
        for(j=0; j<n; ++j)
        {
            if(i==0&&edge[i][j].f<INF) maxflow+=edge[i][j].f;
            if(edge[i][j].f<INF) cout<<i<<"->"<<j<<":"<<edge[i][j].f<<endl;
        }
    cout<<"maxflow:"<<maxflow<<endl;
}
int main()
{
    int u,v,c,f;//弧的起点终点容量流量
    cin>>n>>m;//顶点个数、弧数
    for(i=0; i<n; ++i)
        for(j=0; j<n; ++j)
            edge[i][j].c=edge[i][j].f=INF;//初始化，INF表示无边相连
    for(i=0; i<m; ++i)
    {
        cin>>u>>v>>c>>f;
        edge[u][v].c=c;//构造邻接矩阵
        edge[u][v].f=f;
    }
    ford();
    return 0;
}
/*
6 10
0 1 8 0
0 2 4 0
1 3 2 0
1 4 2 0
2 1 4 0
2 3 1 0
2 4 4 0
3 4 6 0
3 5 9 0
4 5 7 0
*/

4 5
0 1 4 4
0 2 3 0
1 2 2 2
1 3 4 2
2 3 2 2

有反向边的测试数据