poj 1273 Drainage Ditches (网络流 最大流)

题目链接：

　　http://poj.org/problem?id=1273

题目大意：

　　n条边，m个点，每条边都有一个最大流量，问，源点1到汇点m的最大流？

解题思路：

　　模板网络流，要注意的是会有重边。(~_~很小白，模板网络流，但是我还是想发博，毕竟第一道网络流嘛，也算是丰富博客内容。。。。。)

代码：

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <iostream>
#include <cmath>
#include <queue>
using namespace std;

#define maxn 0x3f3f3f3f
#define N 210
int map[N][N], Layer[N], n, m;
bool visit[N];

bool CountLayer ();
int Dinic ();
int main ()
{
    while (scanf ("%d %d", &n, &m) != EOF)
    {
        int s, e, v;
        memset (map, 0, sizeof(map));
        for (int i=0; i<n; i++)
            {
                scanf ("%d %d %d", &s, &e, &v);
                map[s][e] += v;//会出现重复边
            }
        printf ("%d
", Dinic());
    }
    return 0;
}

bool CountLayer ()
{//给残余网络分层
    deque <int> Q;
    memset (Layer, -1, sizeof(Layer));//初始化层编号为-1
    Layer[1] = 1;//初始化源点
    Q.push_back(1);//源点进队
    while (!Q.empty())
    {
        int nd = Q.front();
        Q.pop_front();
        for (int i=1; i<=m; i++)
        {
            if (map[nd][i] > 0 && Layer[i] == -1)
            {
                Layer[i] = Layer[nd] + 1;
                if (i == m)//分层到汇点就可以停止了
                    return true;
                else
                    Q.push_back(i);
            }
        }
    }
    return false;
}
int Dinic ()
{
    int  maxnflow = 0;
    while (CountLayer())
    {//能够分层成功就存在增广路
        deque <int> Q;//dfs队列
        memset (visit, 0, sizeof(visit));
        visit[1] = 1;//源点入队
        Q.push_back(1);
        while (!Q.empty())
        {
            int nd = Q.back(), i;
            if (nd != m)
            {
                for (i=1; i<=m; i++)
                {
                    if (map[nd][i] > 0 && Layer[nd] + 1 == Layer[i] && !visit[i])
                    {//dfs下一层，没有走过的节点
                        visit[i] = 1;
                        Q.push_back(i);
                        break;
                    }
                }
                if (i > m)//在下一层里找不到点，退出本层点，以便继续dfs
                    Q.pop_back();
            }
            else//末点是汇点，则找到一条增广路经
            {
                int mflow = maxn;//增广流量
                int mv;//最小容量边的起点
                for (i=1; i<Q.size(); i++)
                {//遍历经过的边，路径上容量最小的边，就是增广流量
                    int ns, ne;
                    ns = Q[i-1];
                    ne = Q[i];
                    if (map[ns][ne] < mflow)
                    {
                        mflow = map[ns][ne];
                        mv = ns;
                    }
                }
                maxnflow += mflow;//增广，改图
                for (i=1; i<Q.size(); i++)
                {
                    int ns, ne;
                    ns = Q[i-1];
                    ne = Q[i];
                    map[ns][ne] -= mflow;//修改边容量
                    map[ne][ns] += mflow;//增加反向边
                }
                while (!Q.empty() && Q.back() != mv)
                    Q.pop_back();//出队，以便增广下一条路径
            }
        }
    }
    return maxnflow;
}