最大流，最小割（水塘，uva 1515）

最大流是由最小割决定的，一个木桶能装多少水是由最短的那块木板决定的，一条路单位时间最多能通过多少辆车是由最窄的那个路口决定的。

http://blog.csdn.net/jijijix/article/details/51941014 盗个图

http://www.cnblogs.com/jerryRey/p/4761919.html 一些参考

容量表示断开这条弧的费用。

求最大流的同时就求得了最小割，此时最小割均满载，即均断开。

满载的弧表示我已经决定花费那么多流量去断开这条弧。

没满载的弧表示暂时不需要断开你，但以后不一定，先记录着。

满载的弧可以是草与洞之间的，表示决定建篱笆，这样草洞就隔开了。

也可以是S与草之间的，表示决定草变洞，变成同类了，不需要隔开。

也可以是洞与T之间的，表示决定洞变草，同上。

显然草不能变成洞再变成草，因为草不与T向量，洞同理。

然而草草边与洞洞边是干什么用的呢？

首先我们会想到一些糟糕的事情，比如寻增广路时会在草草，洞洞以及草洞边跳来跳去，但仔细思考会发现，这并不能影响结果，而且S草边甚至可以认为是共用的，这样思考能极大化简问题。

草草边是有它的作用的。

它能把这个草的流量传达给另一个草。

这时被传达的草就会有更多的流量，从而更容易使草洞边满载。具体意义就是说：你不是要在建篱笆和草变洞之间抉择吗？但你要考虑与你相邻的草的感受呀，你的邻居可不希望你变洞（变洞就要建篱笆啦），因此给你一些额外的费用赞助你建篱笆。事实上每次传达一个篱笆的流量。

又仔细想了想，其实就是我周围都是草，我又不想变洞，那我就让我周围的草去考虑建篱笆。他们不管变不变洞，反正我上下左右的篱笆是一定要建的，不管建在谁的身上。

如果你决定变成洞，那那些原来的草草边有什么用呢？答案是草草边依然是草草边，我只是暂时变洞，但以后如果有更好的选择，我再改，草草边上的流量就是一种记录，记录着暂时没选建篱笆。但或许今后我会改主意去建篱笆。

可是S草边不是已经满载了吗？怎么改啊？答案：S草边可以认为共用的，一定有别的草会变洞，只是显示在你这里罢了。

洞洞边同理。

思考了一段时间的结论，不知道对不对。

代码

#include<stdio.h>
#include<vector>
#include<queue>
#include<string.h>
#define maxn 3000
#define INF 0X3F3F3F3F
using namespace std;

char MAP[60][60];
int MOVE[4][2]=
{
    { 1, 0},{-1, 0},{ 0, 1},{ 0,-1}
};

struct Edge
{
    int from,to,cap,flow;
    Edge(int u,int v,int c,int f):from(u),to(v),cap(c),flow(f){}
};


struct EdmondsKarp
{
    int n,m;
    vector<Edge>edges;
    vector<int>G[maxn];
    int a[maxn];
    int p[maxn];

    void init(int n)
    {
        this->n=n;
        for(int i=0;i<n;i++) G[i].clear();
        edges.clear();
    }

    void AddEdge(int from,int to,int cap)
    {
        edges.push_back(Edge(from,to,cap,0));
        edges.push_back(Edge(to,from,0,0));
        m=edges.size();
        G[from].push_back(m-2);
        G[to].push_back(m-1);
    }

    int Maxflow(int s,int t)
    {
        int flow=0;
        for(;;)
        {
            memset(a,0,sizeof(a));
            queue<int>Q;
            Q.push(s);
            a[s]=INF;
            while(!Q.empty())
            {
                int x=Q.front();Q.pop();
                for(unsigned int i=0;i<G[x].size();i++)
                {
                    Edge& e=edges[G[x][i]];
                    if(!a[e.to]&&e.cap>e.flow)
                    {
                        p[e.to]=G[x][i];
                        a[e.to]=min(a[x],e.cap-e.flow);
                        Q.push(e.to);
                    }
                }
                if(a[t]) break;
            }
            if(!a[t]) break;
            for(int u=t;u!=s;u=edges[p[u]].from)
            {
                edges[p[u]].flow+=a[t];
                edges[p[u]^1].flow-=a[t];
            }
            flow+=a[t];
        }
        return flow;
    }
};

int w,h,d,f,b;
int id(int i,int j)
{
    return i*w+j+1;
}

int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d%d%d%d",&w,&h,&d,&f,&b);
        for(int i=0;i<h;i++) scanf("%s",MAP[i]);
        int cnt=0;
        for(int i=0;i<w;i++)
        {
            if(MAP[0][i]=='.'){cnt++;MAP[0][i]='#';}
            if(MAP[h-1][i]=='.'){cnt++;MAP[h-1][i]='#';}
        }
        for(int i=0;i<h;i++)
        {
            if(MAP[i][0]=='.'){cnt++;MAP[i][0]='#';}
            if(MAP[i][w-1]=='.'){cnt++;MAP[i][w-1]='#';}
        }
        int ans=cnt*f;
        EdmondsKarp ek;
        ek.init(w*h+2);
        for(int i=0;i<h;i++)
            for(int j=0;j<w;j++)
            {
                if(i==0||j==0||i==h-1||j==w-1)
                    ek.AddEdge(0,id(i,j),INF);
                else if(MAP[i][j]=='#')
                    ek.AddEdge(0,id(i,j),d);
                else ek.AddEdge(id(i,j),w*h+1,f);
                for(int k=0;k<4;k++)
                {
                    int ii=i+MOVE[k][0];
                    int jj=j+MOVE[k][1];
                    if(ii>=0&&ii<h&&jj>=0&&jj<w)
                        ek.AddEdge(id(i,j),id(ii,jj),b);
                }
            }
        ans+=ek.Maxflow(0,h*w+1);
        printf("%d\n",ans);
    }
    return 0;
}