HDU 1532 Drainage Ditches (最大流)

问题描述：

Problem Description
Every time it rains on Farmer John’s fields, a pond forms over Bessie’s favorite clover patch. This means that the clover is covered by water for awhile and takes quite a long time to regrow. Thus, Farmer John has built a set of drainage ditches so that Bessie’s clover patch is never covered in water. Instead, the water is drained to a nearby stream. Being an ace engineer, Farmer John has also installed regulators at the beginning of each ditch, so he can control at what rate water flows into that ditch.
Farmer John knows not only how many gallons of water each ditch can transport per minute but also the exact layout of the ditches, which feed out of the pond and into each other and stream in a potentially complex network.
Given all this information, determine the maximum rate at which water can be transported out of the pond and into the stream. For any given ditch, water flows in only one direction, but there might be a way that water can flow in a circle.

Input
The input includes several cases. For each case, the first line contains two space-separated integers, N (0 <= N <= 200) and M (2 <= M <= 200). N is the number of ditches that Farmer John has dug. M is the number of intersections points for those ditches. Intersection 1 is the pond. Intersection point M is the stream. Each of the following N lines contains three integers, Si, Ei, and Ci. Si and Ei (1 <= Si, Ei <= M) designate the intersections between which this ditch flows. Water will flow through this ditch from Si to Ei. Ci (0 <= Ci <= 10,000,000) is the maximum rate at which water will flow through the ditch.

Output

        For each case, output a single integer, the maximum rate at which water may emptied from the pond.

Sample Input
5 4
1 2 40
1 4 20
2 4 20
2 3 30
3 4 10

Sample Output
50

大致题意：

给出一个有向图，每条边都有一个最大流量，问从1到m的最大流~

思路分析：

最大流。EK算法。
多次bfs找增广路径。直到找全。

ac代码：

#include<bits/stdc++.h>
using namespace std;

const int VM=220;
const int INF=0x3f3f3f3f;

int n,m,max_flow;   //max_flow是最大流
int mapp[VM][VM],flow[VM][VM];   // mapp[i][j]是每条边的容量,flow[i][j]是每条边的流量
int res[VM],pre[VM];    //res[]是每个点的剩余流量,pre[]是每个点的父亲

int EK(int src,int des)
{
    max_flow=0;
    queue<int> q;
    while(!q.empty())
        q.pop();
    memset(flow,0,sizeof(flow));    //最开始每条边的流量都是0
    while(1)
    {
        memset(res,0,sizeof(res));  //残余流量得变0,一开始所有点都没流入对吧
        res[src]=INF;   //源点嘛,剩余流量无限是必须的...
        q.push(src);    //从源点开始进行BFS找增广路
        int u,v;
        while(!q.empty())
        {
            u=q.front();
            q.pop();
            for(v=1; v<=m; v++)     //遍历所有点,找可行边
                if(!res[v] && mapp[u][v]>flow[u][v])     //该点剩余流量为0 且 容量大于流量,也就是找到了新的结点
                {
                    pre[v]=u;   //找到新结点,父节点得记录一下吧
                    q.push(v);
                    res[v]=min(res[u],mapp[u][v]-flow[u][v]);    //如果u的剩余流量能填满uv就填满,不能的话就把u这点的流量全部流向uv
                    cout<<"u: "<<u<<"  v: "<<v<<" res: "<<res[v]<<endl;
                }
        }
        cout<<res[des]<<endl;
        if(res[des]==0)     //如果当前已经是最大流,汇点没有残余流量
            return max_flow;
        for(u=des; u!=src; u=pre[u])    //如果还能增广,那么回溯,从汇点往回更新每条走过的边的流量
        {
            flow[pre[u]][u]+=res[des];  //更新正向流量   （注意这里更新的是流量，而不是容量）
            flow[u][pre[u]]-=res[des];  //更新反向流量
        }
        max_flow+=res[des];
    }
}

int main()
{

    //freopen("input.txt","r",stdin);

    while(~scanf("%d%d",&n,&m))
    {
        memset(mapp,0,sizeof(mapp));
        memset(pre,0,sizeof(pre));
        int u,v,w;
        while(n--)
        {
            scanf("%d%d%d",&u,&v,&w);
            mapp[u][v]+=w;   //有重边  单向？
        }
        printf("%d\n",EK(1,m));
    }
    return 0;
}