poj 1273 Drainage Ditches（最大流）

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#include<queue>
#include<algorithm>
#define N 210
#define INF 0x3f3f3f3f

using namespace std;

int G[N][N], vis[N], layer[N];
int n;

bool BFS()//分层处理
{
    deque<int>Q;//定义双端队列
    memset(layer, -1, sizeof(layer));
    Q.push_back(1);//源点入队列(双端队列尾部增加一个元素x)
    layer[1] = 1;//标记源点
    while(!Q.empty())
    {
        int u = Q.front(), i;
        Q.pop_front();//删除双端队列中最前一个元素
        for(i = 1 ; i <= n ; i++)//遍历点判断是否能分层
        {
            if(G[u][i] > 0 && layer[i] == -1)//当u点到i点这条边有流量且i点尚未被分层
            {
                layer[i] = layer[u] + 1;//则将i点分层
                if(i == n)//当到达汇点时分层成功
                    return true;
                else
                    Q.push_back(i);//否则继续
            }
        }
    }
    return false;
}

int Dinic()
{
    int Maxflow = 0;
    while(BFS() == true)
    {
        deque<int>Q;
        memset(vis, 0, sizeof(vis));
        Q.push_back(1);
        vis[1] = 1;
        while(!Q.empty())
        {
            int v = Q.back(), i;
            if(v != n)
            {
                for(i = 1 ; i <= n ; i++)
                {
                    if(G[v][i] > 0 && layer[v] + 1 == layer[i] && !vis[i])//如果v到i有流量且i点是v点的增广路且点i未被访问过
                    {
                        vis[i] = 1;
                        Q.push_back((i));//点i进入队列（即点i属于增广路上的一个点）
                        break;
                    }
                }
                if(i > n)//如果遍历所有点后在下一层没有找到增广路，就退出本层继续寻找下一条
                    Q.pop_back();//删除双端队列中最后一个元素
            }//找增广路
            else
            {
                int Minflow = INF, nv;
                int len = Q.size();//进入队列中点的个数
                for(int i = 1 ; i < len ; i++)
                {
                    int x = Q[i - 1];//前一个点
                    int y = Q[i];//后一个点
                    if(Minflow > G[x][y])
                    {
                        Minflow = G[x][y];
                        nv = x;//nv记录前端点
                    }//查找最小值即增光流量
                }
                Maxflow += Minflow;
                for(int i = 1 ; i < len ; i++) //更新流量
                {
                    int x = Q[i - 1];
                    int y = Q[i];
                    G[x][y] -= Minflow;//更新正向
                    G[y][x] += Minflow;//反向增加
                }
                while(!Q.empty() && Q.back() != nv)
                    Q.pop_back();//出队
            }
        }
    }
    return Maxflow;
}

int main()
{
    int a, b, c, m;
    while(~scanf("%d%d", &m, &n))
    {
        memset(G, 0, sizeof(G));
        while(m--)
        {
            scanf("%d%d%d", &a, &b, &c);
            G[a][b] += c;//处理重边
        }
        printf("%d\n", Dinic());
    }
    return 0;
}
/*
10 8
1 2 10
1 3 10
2 4 20
2 5 20
3 6 20
3 7 20
4 8 30
5 8 30
6 8 30
7 8 30
*/