poj1273 Drainage Ditches（最大流EKarp+Dinic+模板总结）

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

题意：农夫的田野每次一到下雨就会被淹没，这让他很苦恼。于是修了好多渠沟，编号为1作为池塘，编号为n作为小溪，求从池塘到小溪的最大排水量。

ps：最大流第一题。

思路：花了一段时间来入门，这个是EKarp的教程，并且参考了这个代码。现在感觉这个算法好神奇。首先扩展方式精辟，按照我们普通的想法，每找到一条增广路，就将其加上求得源点的最大流。但是这样离源点近路的流量就有可能超过容量限制，解决办法自然是加判断条件。但是每一条都判断很麻烦，所以就索性变成容量相减的形式，这种减容量的方法明显要强于加流量。

整体思路是用bfs找增广路，并记录前驱。找到后逆向往回找增广路流量。流量求出后再逆向往回分别对正反流量更新。总的来说所有操作都在一个bfs操作里进行，bfs是主线。

不过最精辟的还是反向边的建立，我们再拿神图来说明：

通过原博客的分析，走了1234这条路，就无法走其他的路了。换句话说，本来124和134最大流为2的方案变成了1。根本原因就是没有一个后悔的机会，而建立反向边就可以解决，相当于退回流量。

加一点我自己的理解，打个比方两个人AB是敌人，都想通过自己的方案来得到一种物品，但过程是坎坷的。A走到一半发现B的方案比自己好，以为自己得不到想要的，就中途放弃自己的抢了B的方案。看吧，本来两个人都能得到这种物品(上帝视角)，被A捣乱的只有一个人能得到，但是如何能达到原来最满意的效果呢？B表示不想和A讲话并向A扔了一坨屎，然而A依旧不让步，可怜的B没办法了，就想，你抢我的方案，那我也能抢你的啊，于是接手了原先A放弃的方案。A不知道原来自己的方案也能成功，所以勤恳的B按照自己的方案和自己同时获得了物品。当然这前提是AB原本的方案都可行，如果原本A不可行B可行，那AB就只能打架了，然而不管谁赢最满意的结果也都是一个人获得。

感觉自己叙述的有点辣鸡，多看看那个大牛的博客，自己模拟一下就好~本质上还是比较像贪心思想的，因为想达到最满意的结果嘛。

#include <stdio.h>#include <algorithm>#include <stdlib.h>#include <string.h>#include <iostream>#include <queue>#include <stack>#include <ctype.h>using namespace std;typedef long long LL;const int N = 1005;const int INF = 0x3f3f3f3f;int cap[N][N], pre[N];//cap表示每条路的容量bool vis[N];int n, m;int EKarp(){    int num = 0;//最大流    while(1)    {        queue<int>que;        memset(vis, false, sizeof(vis));        memset(pre, 0, sizeof(pre));        que.push(1);        vis[1] = true;        while(!que.empty())        {            int cnt = que.front();            que.pop();            if(cnt == n) break;            for(int i = 1; i <= n; i++)            {                if(!vis[i] && cap[cnt][i]>0)//未被访问并且这路容量大于0，可以走                {                    vis[i] = true;                    que.push(i);                    pre[i] = cnt;                }            }        }        if(vis[n] == false) break;//做完了搜索仍然没有到达汇点，那么就说明找不到增广路了        int minf = INF;        //逆向往回找不超过这整条路任一段限制的最大流量，也就是增广路        for(int i = n; i != 1; i = pre[i])        {            minf = min(minf, cap[pre[i]][i]);        }        //逆向往回更新容量，将其路上每一段的容量减去增广路流量        //注意流量加一通过将其看成容量减一，以方便程序实现        for(int i = n; i != 1; i = pre[i])        {            cap[pre[i]][i] -= minf;//正向容量减去增广路的容量，表示已经流过            cap[i][pre[i]] += minf;//反向容量加上增广路的容量，表示退回流量新建一条路，给“潜在的路”一次选择的余地        }        num+=minf;    }    return num;}int main(){   // freopen("in.txt", "r", stdin);    int s, t, w;    while(~scanf("%d%d", &m, &n))    {        memset(cap, 0, sizeof(cap));        for(int i = 1; i <= m; i++)        {            scanf("%d%d%d", &s, &t, &w);            cap[s][t] += w;//重边        }        int ans = EKarp();        printf("%d\n", ans);    }    return 0;}

Dinic算法：

ps：这个模板理解+变成自己的几乎总结了一天，归根结底还是对两种搜索结合的邻接表示不熟悉吧。

思路：首先是教程，参考了这个代码。整体思路是先用bfs将可以增广的路分层，然后用dfs在已经分层的基础上按照层次递归。这样dfs相当于O(n)的复杂度，整体还是bfs最费时间，但是相对于Ekarp多了分层减去了好多不必要的操作，所以从16ms减到了0ms~。里面的反向边同样是“后悔”的操作，和上面的原理一样，理解了就不觉得难了。但是说是这么说的，具体实现我认为挺繁琐的，看代码里的注释吧。

#include <stdio.h>#include <algorithm>#include <stdlib.h>#include <string.h>#include <iostream>#include <queue>#include <stack>#include <ctype.h>using namespace std;typedef long long LL;const int N = 1005;const int INF = 0x3f3f3f3f;int head[N], dis[N], cur[N];//dis代表层数bool vis[N];int n, m, cnt;struct Edge{    int to, cap, flow, next;}edge[N*2];void add(int u, int v, int w)//双向加边{    edge[cnt] = (struct Edge){v, w, 0, head[u]};    head[u] = cnt++;    edge[cnt] = (struct Edge){u, 0, 0, head[v]};//反向容量设为0    head[v] = cnt++;}bool bfs(int start, int endd){    memset(dis, -1, sizeof(dis));    memset(vis, false, sizeof(vis));    queue<int>que;    dis[start] = 0;//起点入队列，是第0层    vis[start] = true;    que.push(start);    while(!que.empty())    {        int u = que.front();        que.pop();        for(int i = head[u]; i != -1; i = edge[i].next)        {            Edge E = edge[i];            if(!vis[E.to] && E.flow<E.cap)//若没被访问过且有可以增广的流量，则将下一个节点定义为下一层            {                dis[E.to] = dis[u]+1;                vis[E.to] = true;                if(E.to == endd) return true;//如果到终点了，则返回已经找到了路                que.push(E.to);            }        }    }    return false;//没找到就返回false}int dfs(int x, int res, int endd)//x代表递归那一层的层号，res代表可增流量空间的大小，endd代表终点{    if(x==endd || res==0) return res;//到达终点或者没有可增流量，返回还可以增加的流量    int flow = 0, f;//flow代表增广路的流量，每次递归返回此值。f代表上次递归回来的流量，只是个中介。    for(int& i = cur[x]; i != -1; i = edge[i].next)    {        Edge E = edge[i];        if(dis[E.to]==dis[x]+1)        {            //如果符合比上一层低才能进行下一层操作            f = dfs(E.to, min(res, E.cap-E.flow), endd);//往下递归并更新流量            if(f>0)//如果返回的流大于0            {                edge[i].flow+=f;//正向加流量                edge[i^1].flow-=f;//反向减流量                flow+=f;//增广路流量加上                res-=f;//剩余可增空间流量减去                if(res == 0) break;//减去后如果没有剩余，则停止继续递归            }        }    }    return flow;//返回当前增广路的流量}int max_flow(int start, int endd){    int flow = 0;    while(bfs(start, endd))//只要可以找到他的增广路，就把他的流量加上    {        memcpy(cur, head, sizeof(head));        flow += dfs(start, INF, endd);    }    return flow;}void init(){    cnt = 0;    memset(head, -1, sizeof(head));}int main(){   // freopen("in.txt", "r", stdin);    int s, t, w;    while(~scanf("%d%d", &m, &n))    {        init();        for(int i = 1; i <= m; i++)        {            scanf("%d%d%d", &s, &t, &w);            add(s, t, w);        }        int ans = max_flow(1, n);        printf("%d\n", ans);    }    return 0;}