Uva -1515 Pool construction(最小割)

输入一个字符矩阵，'.'代表洞，'#'代表草地。可以把草改成洞花费为d，或者把洞改成草花费为f，最后还要在草和洞之间修围栏花费为b。

首先把最外一圈的洞变成草，并累加花费。

增加一个源点和一个汇点，源点连接每个草地，汇点连接每个洞。

源点与最外一圈的草地连一条容量无穷大的边，与其他草地连一条容量为d的边。表示把这条弧切断，割的容量增加d，草就会变成洞。

每个洞与汇点连一条容量为f的边。

相邻两个格子之间连一条双向边。

用最大流算法求最小割在加上之前把边界上的洞变成草的费用，就是最小花费。

用最小的费用将对象划分成两个集合的问题常常可以转换成最小割顺利解决.这道题就可以考虑将每一个点变成草地和洞分成两个集合.

如果通过合适的建边使得花费的总和等价于割的容量的话,那么为了求最小花费只要求最小割就好.

 #include <iostream>
 #include <cstdio>
 #include <cmath>
 #include <vector>
 #include <cstring>
 #include <string>
 #include <algorithm>
 #include <string>
 #include <set>
 #include <functional>
 #include <numeric>
 #include <sstream>
 #include <stack>
 #include <map>
 #include <queue>
 #pragma comment(linker, "/STACK:102400000,102400000")
 #define CL(arr, val)    memset(arr, val, sizeof(arr))

 #define ll long long
 #define inf 0x7f7f7f7f
 #define lc l,m,rt<<1
 #define rc m + 1,r,rt<<1|1
 #define pi acos(-1.0)

 #define L(x)    (x) << 1
 #define R(x)    (x) << 1 | 1
 #define MID(l, r)   (l + r) >> 1
 #define Min(x, y)   (x) < (y) ? (x) : (y)
 #define Max(x, y)   (x) < (y) ? (y) : (x)
 #define E(x)        (1 << (x))
 #define iabs(x)     (x) < 0 ? -(x) : (x)
 #define OUT(x)  printf("%I64d\n", x)
 #define lowbit(x)   (x)&(-x)
 #define Read()  freopen("a.txt", "r", stdin)
 #define Write() freopen("b.txt", "w", stdout);
 #define maxn 1010
 #define maxv 3000
 #define mod 1000000000
 using namespace std;

 struct edge
 {
     int to,cap,rev;
     edge(){}
     edge(int x,int y,int z)
     {
         to=x;
         cap=y;
         rev=z;
     }
 };

 vector<edge>G[maxv];
 int level[maxv];
 int iter[maxv];

 void Add_Edge(int from,int to,int cap)
 {
     G[from].push_back((edge){to,cap,G[to].size()});
     G[to].push_back((edge){from,,G[from].size()-});
 }

 void bfs(int s)
 {
     memset(level,-,sizeof(level));
     queue<int>que;
     level[s]=;
     que.push(s);
     while(!que.empty())
     {
         int v=que.front();que.pop();
         for(int i=;i<G[v].size();i++)
         {
             edge &e=G[v][i];
             if(e.cap>&&level[e.to]<)
             {
                 level[e.to]=level[v]+;
                 que.push(e.to);
             }
         }
     }
 }
 int dfs(int v,int t,int f)
 {
     if(v==t) return f;
     for(int &i=iter[v];i<G[v].size();i++)
     {
         edge &e=G[v][i];
         if(e.cap>&&level[v]<level[e.to])
         {
             int d=dfs(e.to,t,min(f,e.cap));
             if(d>)
             {
                 e.cap-=d;
                 G[e.to][e.rev].cap+=d;
               //  printf("%d %d %d\n",e.to,e.rev,G[e.to][e.rev]);
                 return d;
             }
         }
     }
     return ;
 }

 int max_flow(int s,int t)
 {
     int flow=;
     for(;;)
     {
         bfs(s);
         if(level[t]<) return flow;
         memset(iter,,sizeof(iter));
         int f;
         while((f=dfs(s,t,inf))>)
         flow+=f;
     }
 }
 char s[][];
 int w,h;
 int ID(int i,int j)
 {
     return i*w+j;
 }
 int main()
 {
     //freopen("a.txt","r",stdin);
     int t,d,f,b;
     scanf("%d",&t);
     while(t--)
     {
         scanf("%d%d%d%d%d",&w,&h,&d,&f,&b);
         for(int i=;i<w*h+;i++)
             G[i].clear();
         for(int i=;i<h;i++)
         {
             scanf("%s",s[i]);
         }
         int cost=;
         for(int i=;i<h;i++)
         {
             if(s[i][]=='.') {s[i][]='#';cost+=f;}
             if(s[i][w-]=='.') {s[i][w-]='#';cost+=f;}
         }
         for(int i=;i<w;i++)
         {
             if(s[][i]=='.') {s[][i]='#';cost+=f;}
             if(s[h-][i]=='.'){s[h-][i]='#';cost+=f;}
         }
         for(int i=;i<h;i++)
         {
             for(int j=;j<w;j++)
             {
                 if(s[i][j]=='#')
                 {
                     int cap=inf;
                     if(i>&&i<h-&&j>&&j<w-) cap=d;
                     Add_Edge(w*h,ID(i,j),cap);
                     if(i>) {Add_Edge(ID(i,j),ID(i-,j),b);}
                     if(i<h-) {Add_Edge(ID(i,j),ID(i+,j),b);}
                     if(j>) {Add_Edge(ID(i,j),ID(i,j-),b);}
                     if(j<w-) {Add_Edge(ID(i,j),ID(i,j+),b);}
                 }
                 else
                 {
                     Add_Edge(ID(i,j),w*h+,f);
                     if(i>) {Add_Edge(ID(i,j),ID(i-,j),b);}
                     if(i<h-) {Add_Edge(ID(i,j),ID(i+,j),b);}
                     if(j>) {Add_Edge(ID(i,j),ID(i,j-),b);}
                     if(j<w-) {Add_Edge(ID(i,j),ID(i,j+),b);}
                 }
             }
         }
         printf("%d\n",cost+max_flow(w*h,w*h+));
     }
     return ;
 }