POJ-1273 网络最大流(ek)

题目传送门 ： http://poj.org/problem?id=1273

 

题意：一个农场排水系统，n条小溪，m个排水沟，求从排水沟1到排水沟m的最大水流量，需要注意的是两个排水沟之间可能不只有一条小溪。

 

第一次学习网络最大流，过程可以说是极为坎坷。先是看不懂残量图，接着又看不懂增广路，最后花了N个小时终于有点看懂了，开始敲代码又wa无数= =，整个人都是崩溃的，搞了一天终于算是a了。

虽然花了一天的时间才把模版题搞懂，但还是有很多收获的，在数十次的wa中，也对ek算法有了更深入的理解=。（全当是安慰自己了= =）

刚开始wa是因为在ek算法的两个循环中i表意混乱，i一会儿表示边的编号，一会儿表示点的编好，然后导致wa了两发，接下来的n发wa是因为没看到题目中的，两个排水沟之间不只有一条小溪= =。而且，两个排水沟之间可能是双向的。也就是没有处理重边的问题。

还有是这题居然是多组数据，但题目中没说，以后需要注意一下。

最后在不断wa中发现，即使边是双向的ek算法依然成立，开始还以为只能是单向的，也算是意外收获吧，不wa这么多次也不会发现。

 

然后就是ek算法：

这个博客讲的很不错 http://blog.csdn.net/qiankun1993/article/details/6782838

就是建残量图然后再用增广路的方法维护残量图直到无法从1到m。

这道题其实用二维数组就可以维护图，但想增加一下难度就用了前向星，所以这个模版也适用于m比较大的情况。

 

代码如下：

 

#include <map>
#include <set>
#include <stack>
#include <queue>
#include <cmath>
#include <string>
#include <vector>
#include <cstdio>
#include <cctype>
#include <cstring>
#include <sstream>
#include <cstdlib>
#include <iostream>
#include <algorithm>
using namespace std;

#define   lowbit(x)     x&(-x)
#define   lson          l,m,rt<<1
#define   rson          m+1,r,rt<<1|1
#define   ll            long long
#define   ull           unsigned long long
#define   mem(n,v)      memset(n,v,sizeof(n))
#define   MAX           3005
#define   MAXN          2000005
#define   PI            3.1415926
#define   E             2.718281828459
#define   opnin         freopen("text.in.txt","r",stdin)
#define   clsin         fclose(stdin)

const int    INF    =   0x3f3f3f3f;
const ll     INFF   =   0x3f3f;
const double pi     =   3.141592653589793;
const double inf    =   1e18;
const double eps    =   1e-8;
const ll     mod    =   1e9+7;
const ull    mx     =   133333331;

struct edge
{
    int from,to,next;
    int flow,cap;
    edge(int u = 0,int v = 0,int c = 0,int f = 0,int n = 0):from(u),to(v),cap(c),flow(f),next(n) {}
};
int head[MAX];
int n,m,Count;
int a[MAX];
int p[MAX];
struct edge edges[MAX];
void init()
{
    mem(edges,0);
    mem(a,0);
    mem(p,0);
    mem(head,-1);
    Count = n = m = 0;
}
void addedge(int u,int v,int val)
{
    edges[Count].from = u;
    edges[Count].to = v;
    edges[Count].cap = val;
    edges[Count].next = head[u];
    head[u] = Count++;
}
int EK()
{
    int sflow = 0;
    for(;;){
        mem(a,0);
        mem(p,0);
        queue<int>q;
        q.push(1);
        a[1] = INF;
        while(!q.empty()){
            int x = q.front();
            q.pop();
            for(int i=head[x];i != -1; i = edges[i].next){//i edge number
                if(!a[edges[i].to] && edges[i].cap > edges[i].flow){
                    p[edges[i].to] = i;
                    a[edges[i].to] = min(a[x],(edges[i].cap - edges[i].flow));
                    q.push(edges[i].to);
                }
            }
            if(a[m]) break;
        }
        if(!a[m]) break;
        for(int i=m;i !=1 ;i = edges[p[i]].from){ // i point number
            edges[p[i]].flow += a[m];
            edges[p[i]^1].flow -= a[m];
        }
        sflow += a[m];
    }

    return sflow;
}
int main()
{
    init();
    while(scanf("%d %d",&n,&m) != EOF){//n edges, m points
        int u,v,val;
        for(int i = 1;i<=n;i++){
            scanf("%d %d %d",&u,&v,&val);
            bool flag = false;
            for(int i=head[u];i != -1; i = edges[i].next){
                if(edges[i].to == v){
                    edges[i].cap += val;
                    flag = true;
                    break;
                }
            }
            if(!flag){
                addedge(u,v,val);
                addedge(v,u,0);
                }
        }
        printf("%d\n",EK());
        init();
    }
    return 0;
}