初识网络流（一般增广路算法-Ford-Fulkerson）

这两天看了看求最大网络流的问题。着实有点费脑子。不过还好还是很有收获的。
在这里写的是关于通过找增广路求最大流的算法Ford-Fulkerson。算法的思路是通过BFS利用标记来找增广路。
具体过程如下：
从一个可行流出发（可以是零流），进入标号过程和调整过程：
1：标号过程：
在标号过程中，容量网络中的顶点可以分为三类：
（1）未标号顶点
（2）已标号，未检查相邻顶点
（3）已标号，已检查（即检查所有相邻顶点看是否能标号）
标号分为两个分量：
第一个分量指明标号是从哪个顶点来的，以便找出增广路
第二个分量是为确定可改进量用的
在标号开始时，总是先给Vs表上（0，INF），0表示始点，INF表示可以流出任意值。这是Vs已标号，从Vs开始对他相邻的顶点开始标号：
一般取一个已标号而未检查的顶点u,对一切未标号的顶点v进行如下操作：
（1）若u与v正向连接，且f(u,v)< c(u,v)则给v标上（u,L(v)）,这里L（v）=min(L(u),c(u,v)-f(u,v)),L(u)表示顶点u能提供的，c(u,v)-f(u,v)表示v能接受的，取小者。
（2）若u与v反向连接，且f（v,u）> 0,则给v标号（-u,L(v)）,这里L（v）=min(L(u),f(v,u))。
u的全部相邻顶点检查完后，u就是已检查的顶点了。
重复上述步骤直至汇点获得标号，一旦汇点被标号且第二个分量大于0则说明存在增广路,汇点第二个分量则为可增加流量a，则转为调整过程。若无法达到汇点或汇点的第二个分量为0则结束算法。此时即为最大流。
2调整过程：
标号的第一个分量记录了增广路的路径。将路径上的正向弧的f(u,v)+=a,反向弧的f(v,u)-=a;

例题：
给出一个容量网络，求最大流，并输出所有弧上的流。

输入：
6 10
0 1 8 2
0 2 4 3
1 3 2 2
1 4 2 2
2 1 4 2
2 3 1 1
2 4 4 0
3 4 6 0
3 5 9 3
4 5 7 2

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


const int maxn = 1000;
const int INF = 1000000;

struct node
{
    int c,f;
};

node E[maxn][maxn];
int n,m;
int flag[maxn];
int pre[maxn];
int alpha[maxn];
queue<int> q;

void ford(int vt)
{
    while(1)
    {
        memset(flag,-1,sizeof(flag));
        memset(pre,-1,sizeof(pre));
        memset(alpha,-1,sizeof(alpha));
        flag[vt]=0;pre[vt]=0;alpha[vt]=INF;
        while(!q.empty()) q.pop();
        q.push(vt);
        int v;
        while(!q.empty() && flag[n-1]==-1)
        {
            v=q.front();
            q.pop();
            for(int i=0;i<n;i++)
            {
                if(flag[i]==-1)
                {
                    if(E[v][i].c<INF && E[v][i].f<E[v][i].c)
                    {
                        flag[i]=0;pre[i]=v;
                        alpha[i]=min(alpha[v],E[v][i].c-E[v][i].f);
                        q.push(i);
                    }
                    else if(E[i][v].c<INF && E[i][v].f>0 && E[i][v].f<INF)
                    {
                        flag[i]=0;pre[i]=-v;
                        alpha[i]=min(alpha[v],E[i][v].f);
                        q.push(i);
                    }
                }
            }
        }
        if(flag[n-1]==-1 || alpha[n-1]==0) break;
        int k1=n-1,k2=abs(pre[k1]);
        int a=alpha[n-1];
        while(1)
        {
            if(E[k2][k1].f<INF)
                E[k2][k1].f+=a;
            else E[k1][k2].f-=a;
            if(k2==0) break;
            k1=k2;k2=abs(pre[k2]);
        }
    }
    int maxf=0;
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<n;j++)
        {
            if(i==0 && E[i][j].f<INF) maxf+=E[0][j].f;
            if(E[i][j].f<INF) printf("%d->%d:%d\n",i,j,E[i][j].f);
        }
    }
    printf("maxflow= %d\n",maxf);
}

int main()
{
    //freopen("in.txt","r",stdin);
    int u,v,c,f;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                E[i][j].c=INF;E[i][j].f=INF;
            }
        }
        for(int i=0;i<m;i++)
        {
            scanf("%d%d%d%d",&u,&v,&c,&f);
            E[u][v].c=c;E[u][v].f=f;
        }
        ford(0);
    }
    return 0;
}