网络流 EdmonsKarp 算法讲解

网络流EK算法
数据结构：队列
主要操作:广搜 记录路径 更新
能解决的问题：最大流（最小割）
复杂度：O(MV)v指最大容量，M指边数。
新名词：
    1.增广路：从源点source到tink的一条简单路，如果路上的每条边（u，v）的可改进量均大于0，则称这条路为一条增广路。
    增广路定理：网络达到最大流量当且仅当不存在增广路。
    增广路算法：从一个可行流开始不断的寻找可增广路，然后沿着它增广，直到它不存在。
    2.反向弧：如果有一条弧(u,v),那么再进行网络流算法时，要对它建立反向弧(v,u),反向弧的容量为0，与正向弧相反，正向弧减少容量时，反向弧增加容量。建立反向弧能更多的增广，使网络流算法正确。（无法给出证明）
    3.可行弧：在EK算法中指可从u到v增加流量（也就是容量不为0）。
    4.可行路：从源点source到tink的有可行弧构成的路径叫做可行路。    

具体操作：
    1.建立网络（正向弧+反向弧）
    2.从源点出发，广搜一条最短可行路（即最先到达汇点tink的那条路），每次到达一个点用pre数组记录是由那条边过来的（为后面减小流量做准备）
    3.到达汇点tink时，按照pre数组记录的，从可行路中找一条容量最小的进行容量减少。即找到了一条割边。
    4.重复操作2.3，直到无法到达汇点，算法结束，即找到了最大流，算法结束。

推荐水题：USACO 4.2.1 纯网络流算法，可用来试EK的正确性，但EK只能拿50分！

#include<cstdio>
#include<iostream>
#include<cstdlib>
#include<cstring>
using namespace std;

#define INF 1000000  

struct    Edge
{
    int x,y,flow,next,op;//flow表示当前边的容量  op表示正向弧所对应的反向弧在边表中的位置
};

Edge map[200];
int que[20000];
bool b[500];//用b数组记录是否入队，可以防止重复入队，因为有反向弧和环！！
int source,tink,n,m,tot,ans,head,tail;
int first[500];
int pre[500];

int fmin(int x ,int y)
{
    if (x<y)    return x;
    else return y;
}

void Build(int x ,int y ,int c)
{
    tot++;//正向弧
    map[tot].x=x;
    map[tot].y=y;
    map[tot].flow=c;
    map[tot].next=first[x];
    first[x]=tot;
    map[tot].op=tot+1;
    tot++;//反向弧
    map[tot].x=y;
    map[tot].y=x;
    map[tot].flow=0;//反向弧容量为0
    map[tot].next=first[x];
    first[x]=tot;
    map[tot].op=tot-1;
}

void init()
{
    memset(first,0,sizeof(first));
    tot=0;     ans=0;
    scanf("%d%d",&m,&n);
    for (int i=1; i<=m; i++)
    {
        int x,y,c;
        scanf("%d%d%d",&x,&y,&c);
        Build(x,y,c);                
    }
    source=n+1;     tink=n+2;//手动建立源点和汇点，看题目要求！
    Build(source,1,INF);
    Build(n,tink,INF);
}

bool Bfs()
{
    memset(b,false,sizeof(b));
    head=1;    tail=1;     que[1]=source;    b[source]=true;    pre[source]=-1;//没有可以到源点的路
    while (head<=tail)
    {
        int x=que[head];
        int t=first[x];        
        while (t>0)
        {
            int y=map[t].y;            
            if (map[t].flow>0    &&    b[y]==false)//找到一条可行弧
            {                
                tail++;
                que[tail]=y;
                b[y]=true;
                pre[y]=t;//路径记录
                if (y==tink)    return true;//到达汇点，退出广搜
            }
            t=map[t].next;
        }
        head++;
        b[x]=false;
    }    
    return false;
}

void updata()
{    
    int Min=INF;
    for (int p=pre[tink];p!=-1;p=pre[map[p].x])    
    {
        Min=fmin(Min , map[p].flow);//找可行路中的最小容量
    }
    for (int p=pre[tink];p!=-1;p=pre[map[p].x])//更新容量过程    
    {
        map[p].flow-=Min;
        map[map[p].op].flow+=Min;//反向弧增加容量
    }
    ans+=Min;    
}

void EK()
{
    
    while (Bfs()==true)
    {
        updata();    
    }
    printf("%d\n",ans);    
}

int main()
{
    freopen("ditch.in","r",stdin);
    freopen("ditch.out","w",stdout);
    init();
    EK();    
    return 0;    
    fclose(stdin); fclose(stdout);
}