最大流--EK_bfs算法

先弄清楚几个概念： 图中有一个源点和一个汇点，最大流要求的就是从源点最多可以有多少流量流入汇点。
每条边包括起点，重点，以及容量cap（一共可以通过的流量），流量flow（当前的流量），残量（cap-flow）
每一条边都可以创建一条反向弧，可以说最大流的核心思想就是这个反向弧， 因为在每一个图创建网络后，必定有一个残量网络，如果存在一条残量路径从源点到汇点（增广路径），那么就是意味着这条路径上的flow 都可以增加残量路径中的最小残量。 如果找不到增广路径，那么意味着该网络已经是最大流网络了。

#include<iostream>
#include<stdio.h>
#include<string.h>
#include<math.h>
#include<algorithm>
#include<stdlib.h>
#include<queue>
#include<stack>
#include<map>
#include<vector>
#define mem(a) memset(a,0,sizeof(a))
#define pfn printf("\n")
#define ll __int64
#define pfd(a) printf("%d\n",a)
#define pf2d(a,b) printf("%d %d\n",a,b)
#define pf3d(a,b,c) printf("%d %d %d\n",a,b,c)
#define pfs(a) printf("%s\n",a)
#define sfd(a) scanf("%d",&a)
#define sf2d(a,b) scanf("%d%d",&a,&b)
#define sf3d(a,b,c) scanf("%d%d%d",&a,&b,&c)
#define sfs(a) scanf("%s",a)
#define sf  scanf
#define pf  printf
#define fr(i,n) for(int i=0;i<n;i++)
const double PI = acos(-1.0);
const double e = exp(1.0);
template<class T> T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }
template<class T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
template<class T> inline T Min(T a, T b) { return a < b ? a : b; }
template<class T> inline T Max(T a, T b) { return a > b ? a : b; }
bool cmpbig(int a,int b){return a>b;}
bool cmpsmall(int a,int b){return a<b;}
using namespace std;
#define INF 0x7fffffff                                          //INT_MAX
#define inf 0x3f3f3f3f
#define maxn 101000
int s,t,n,m;     //一共有n个点，m条边，源点s，汇点t
int map1[305][305];   //领接矩阵存图 
int pre[305];       //领接表存路径
int vis[305];       //标记
int bfs(){
    int i;
    int cur;
    memset(pre,0,sizeof(pre));
    memset(vis,0,sizeof(vis));
    vis[s]=1;      
    queue<int>q;
    q.push(s);
    while(!q.empty()){
        cur=q.front();
        q.pop();
        if(cur==t)
            return 1;            //若为 汇点 即存在增广路径
        for(i=1; i<=n; i++){
            if(!vis[i] && map1[cur][i]){
                vis[i]=1;
                pre[i]=cur;     //每条路径中邻接表肯定会有覆盖问题，但是每条路径互不影响，可以参考刘汝佳的书《入门经典2》P369
                q.push(i);
            }
        }
    }
    return 0;    //若无增广路径，返回0；
}
int Max_flow(){
    int i,ans=0;
    while(1){
        if(!bfs())
            return ans;              //找不增广路径了，返回最大流
        int Min=0x7f7f7f;
        for(i=t; i!=s; i=pre[i]){
            Min=min(Min,map1[pre[i]][i]);    //求增广路径中最小的残量
        }
        for(i=t; i!=s; i=pre[i]){
            map1[pre[i] ][i]-=Min;       // 正向弧 -最小残量
            map1[i][pre[i]]+=Min;      //反向弧 +最小参量
        }
        ans+=Min;         //最大流
    }
    return 0;
}
int main()
{
    int u,v,c;
    while(cin>>m>>n)
    {
        memset(map1,0,sizeof(map1));
        while(m--)
        {
            cin>>u>>v>>c;
            map1[u][v]+=c;
        }
        s=1;
        t=n;
        cout<<Max_flow()<<endl;
    }
    return 0;
}