网络最大流问题 Dinic多路增广

　　网络最大流问题，就是一个有向图G=（v，e）每条边的边权可以想象成一个管道的宽度，水流从起始点流入汇点，即使你之前的流水量很大，但一条通路中最细的管道才是这条路的最终水量，类似于木桶效应，求的是到汇点最大流量是多少。那么具体解决方法就是建造两个图，层次图和剩余图，层次图先用广搜把每个点标上level，从低级流向高级，剩余图如果是从低级向高级，表示的是这条管道还剩多少流量可以使用，反向的从高级流向低级表示的是高级点能够消耗多少流量。也就是两个量相加总是这条管道的宽度。

　　然后便是一次又一次的从起始点流向汇点的搜索，知道无路可搜。

　　嗯刚学的网络最大流，发现dinic多路增广着实好用，比Dinic优化了不少，其主要原理是在找到汇点后不全部return而是继续搜索，期中可增广的流量用total保存，每次拿剩余量-total就是这次所利用的流量。Find函数结束前一定别忘了将无剩余量的“废点”删去，也就是将level变为-1。

　　还有今年的noip可以使用STL对解决问题方面有着极大的帮助，于是我用了下队列容器queue，感觉不错：）

代码如下

#include <iostream>
#include <queue>
using namespace std;

int N, M, level[10001];
struct edge
{
       int v, f;
       edge *next, *rev;
}e[10001], *V[10001];

void init()
{
     int i, x, y, z, top = -1;
     cin >> N >> M;
     for (i = 1; i <= M; i++)
     {
         cin >> x >> y >> z;
         edge *p = &e[++top];
         edge *q = &e[++top];
         p -> v = y;p -> f = z;p -> next = V[x];p -> rev = q;V[x] = p;
         q -> v = x;q -> f = 0;q -> next = V[x];V[y] = q;q -> rev = p;
     } 
}
bool mklevel()
{
     int i;
     queue<int> que;
     for (i = 1; i <= N; i++)
         level[i] = -1;
     level[1] = 0;
     que.push(1);
     while (!que.empty())
     {
           int tmp = que.front();
           que.pop();
           edge *p;
           for (p = V[tmp];p;p = p -> next)
               if (p -> f && level[p -> v] == - 1)
               {
                  que.push(p -> v);
                  level[p -> v] = level[tmp] + 1;
               }
           if (level[N] != - 1)
              return true;
     }
     return false;
}

int Find(int r, int key)
{
    if (r == N)
       return key;
    edge *p;
    int d = 0, tot = 0;
    for (p = V[r]; p && tot < key; p = p -> next)
    {
        if (p -> f && level[p -> v] == level[r] + 1)
        {
           d = Find(p -> v, min(key - tot, p -> f));
           p -> f -= d;
           p -> rev -> f += d;
           tot += d;
        }
    }
    if (!tot)level[r] = -1;
    return tot;
}

int Dinic()
{
    int ret = 0, t;
    while (mklevel())
          while(t = Find(1, INT_MAX)) ret += t;
    return ret;
}

int main()
{
    init();
    cout << Dinic() << endl;
    system("pause");
    return 0;
}