Drainage Ditches - poj 1273（网络流模板）

/************************************/
/** 使用Edmonds-Karp 最短增广路算法*/
/** 邻接矩阵实现                   */
/** 2015/8/7/9:39                   */
/************************************/

#include<stdio.h>
#include<string.h>
#include<queue>
#include<algorithm>
using namespace std;

const int MAXN = 205;
const int oo = 1e9+7;

///1是源点，M是汇点，N条边
int G[MAXN][MAXN], M, N;
int pre[MAXN];///记录每个点的前驱，也就是父节点
bool used[MAXN];

///s代表源点，e代表汇点,可以到达汇返回true，否则返回false
bool BFS(int s, int e)
{
    memset(used, false, sizeof(used));
    queue<int> Q;
    Q.push(s);
    used[s] = true;

    while(Q.size())
    {
        s = Q.front();Q.pop();

        if(s == e) return true;

        for(int i=1; i<=M; i++)
        {
            if(G[s][i] && !used[i])
            {
                pre[i] = s;
                used[i] = true;
                Q.push(i);
            }
        }
    }

    return false;
}
int Karp(int s, int e)
{
    int MaxFlow = 0;

    while( BFS(s, e) == true )
    {///如果有增量
        int MinFlow = oo, v;

        v = e;

        while(v != s)
        {///求出来路径上最小流量
            MinFlow = min(MinFlow, G[pre[v]][v]);
            v = pre[v];
        }

        MaxFlow += MinFlow;
        v = e;

        while(v != s)
        {///边上的所有点减去最小流量，反边增加流量
            G[pre[v]][v] -= MinFlow;
            G[v][pre[v]] += MinFlow;

            v = pre[v];
        }
    }

    return MaxFlow;
}

int main()
{
    while(scanf("%d%d", &N, &M) != EOF)
    {
        int i, u, v, c;

        memset(G, false, sizeof(G));

        for(i=1; i<=N; i++)
        {
            scanf("%d%d%d", &u, &v, &c);
            G[u][v] += c;///有重边，两点间应该算上所有边
        }

        printf("%d\n", Karp(1, M));
    }

    return 0;
}