poj 1273 ---&&--- hdu 1532 最大流模板

最近在换代码布局，因为发现代码布局也可以引起一个人的兴趣
这个方法是算法Edmonds-Karp 最短增广路算法，不知道的话可以百度一下，基于Ford-Fulkerson算法的基础上延伸的 
其实我不是很透彻的领悟这个算法的精髓，只知道怎样实现，现在的任务就是多刷几道题，见识见识题型，就可以更透彻领悟为什么这么做，之后再拐回来研究算法，这样就可以学习和实践相结合！

 
详解 ： 就是每次广搜后都让走过的边减去这条通路的最小的通路，逆向通路加上这条通路的最小通路，也就是最大容纳量，形成新的通路
之后就记录最小通路 maxflow=0 ；maxflow+=minflow；

  1  2  3   4  连接矩阵初始化
1 0 40  0  20 

2 0  0 30  20                                                            
3 0  0  0  10                                                            
4 0  0  0  0                                                             

#include<iostream>
#include<stdio.h>
#include<string.h>
#include<queue>
using namespace std;
#define Min(a, b) a<b?a:b;
#define INF 0x3f3f3f3f

const int N=220;
int river, land;
int G[N][N], pre[N];//previous 先前的

int EK(int s, int e);//start, end
bool BFS(int s, int e);

int main()
{
    while(scanf("%d%d", &river, &land)!=EOF)
    {
        memset(G, 0, sizeof(G));

        int a, b, flow;

        while(river--)
        {
            scanf("%d%d%d", &a, &b, &flow);
            G[a][b]+=flow;//调试的时候发现少了一个‘+’，因为可能有重边
        }

        int ans = EK(1, land);
        printf("%d\n", ans);
    }
    return 0;
}

int EK(int s, int e)
{
    int maxflow=0;//就是要求的最大流
    while(BFS(s, e)==true)//注意这里是while 因为要进行BFS直到整个图都被搜完了，无法再搜了；
    {
        int minflow=INF;//这是定义了最小流，根据木桶原理，其实就是这个通道最大容纳量

        for(int i=e; i!=s; i=pre[i])//这里for循环里面的东西， i从e开始每次都变为它的前一个节点，
             minflow=Min(minflow, G[pre[i]][i]);

        for(int i=e; i!=s; i=pre[i])//修改路径
        {
            G[pre[i]][i]-=minflow;
            G[i][pre[i]]+=minflow;
        }

        maxflow+=minflow;
    }
    return maxflow;
}

bool BFS(int s, int e)
{
    memset(pre, 0, sizeof(pre));

    queue<int>Q;
    Q.push(s);

    while(!Q.empty())
    {
        int i=Q.front(); Q.pop();//队首出队列

        if(i==e)
            return true;

        for(int j=1; j<=e; j++)//调试的时候发现少些一个‘=’ j<=e;
        {
            if(G[i][j]&&pre[j]==0)//当i和j点之间有通路时,且没有被访问过
            {
                pre[j]=i;
                Q.push(j);
            }
        }
    }

    return false;
}