最大流算法_Dinic

/*
最大流之Dinic算法
(1)以原点s为根节点，将所有的节点按深度分层，直到将汇点t找到为止，如果直到最后都没有找到t,那说明没有路径了，最大流结束
(2)从s开始，一层一层的向下寻找t,找到之后，求出最小容量边tr,依次为流量，将各边，减去tr,在将各边反向边加tr
(3)回溯到f点，（f点事距离s最近，且，以该点为端点的边的容量被减为0）之后跳到第二步，继续寻找t的路径，当找不到t时，跳到第一步
*/
#include<iostream>
#include<queue>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define oo 0x3f3f3f3f
const int maxn = 1010;
using namespace std;
struct node
{
    int u,v,c,f,next;
};
node e[maxn*1000];
int head[maxn], tot;
int level[maxn], ps[maxn],cur[maxn];
int ret,n,m;
void Init()
{
    tot=0;
    memset(head, -1, sizeof(head));
}
void Add(int u, int v, int c ,int f)
{
    e[tot].u = u;
    e[tot].v = v;
    e[tot].c = c;
    e[tot].f = f;
    e[tot].next = head[u];
    head[u] = tot++;

    e[tot].u = v;
    e[tot].v = u;
    e[tot].c = f;//逆向为流量
    e[tot].f = 0;
    e[tot].next = head[v];
    head[v] = tot++;
}

int Dinic(int s, int t)
{
    ret = 0;
    int i,j,l,r,k,top,tr;
    while(1)
    {
        //分层
        memset(level, -1, sizeof(level));
        //分层标号
        //l是队列的尾巴，r是头
        for(l = level[ps[0]=s]=0,r=1;l!=r;)//源点进入队列，标记0层，头指针1，尾指针0
        {
            for(i=ps[l++], j=head[i]; j != -1; j=e[j].next)//取出节点，获得第一个边编号j
            {
                if(e[j].c-e[j].f>0 && level[k=e[j].v]==-1)//有流量边，并且层数为访问
                {
                    level[k] = level[i]+1;
                    ps[r++] = k;
                    if(k==t)
                    {
                        l = r;
                        break;
                    }
                }
            }
        }

        if(level[t]==-1)
            break;
        memcpy(cur, head, sizeof(cur));
        i=s;top=0;
        while(1)
        {
            if(i == t)
            {
                for(tr=oo,k=0;k<top;k++)//所以ps存的是边的序号
                    if(tr>(e[ps[k]].c-e[ps[k]].f))
                    {
                        tr = e[ps[k]].c-e[ps[k]].f;
                        l = k;//
                    }
                for(k=0; k < top; k++)
                {
                    if(ps[k]%2==0)//正向
                    {
                        e[ps[k]].f += tr;
                        e[ps[k]^1].c += tr;
                    }
                    else
                    {
                        e[ps[k]].f -= tr;
                        e[ps[k]^1].c -= tr;
                    }   
                }
                i = e[ps[top=l]].u;
                ret += tr;
            }
            //i点的边
            for(j=cur[i]; cur[i]!=-1; j=cur[i]=e[cur[i]].next)
                if(e[j].c-e[j].f>0&&level[i]+1 == level[e[j].v])
                    break;
            //找到了i顶点符合u+1=v的边
            if(cur[i]!=-1)
            {
                ps[top++] = cur[i];//边的编号
                i = e[cur[i]].v;//下一点
            }
            else
            {
                if(top == 0)break;
                level[i] = -1;
                i = e[ps[--top]].u;//回溯
            }
        }
    }
    return ret;
}
int main()
{
    int u,v,c,f;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        Init();
        for(int i = 0; i < m; i++)
        {
            scanf("%d%d%d%d",&u,&v,&c,&f);
            Add(u,v,c,f);
        }
        cout<<Dinic(1,n)<<endl;
    }
    return 0;
}
/*
7  12
1 2 4 0
1 3 10 0
2 3 1 0
2 5 7 0
2 4 2 0
3 4 5 0
3 6 3 0
4 5 6 0
4 6 1 0
5 7 9 0
6 5 5 0
6 7 6 0
4 5
1 2 4 0
1 3 4 0
2 4 4 0
3 4 4 0
2 3 1 0

*/