uva1515

这个题属于最大流算法的灵活运用~~

首先像刘汝佳所说的，根据“隔开”想到了割的概念，那么就可以把草放在一列，把洞放在一列，砍断每一条边的费用是b；

现在引入源节点s和汇点t，s连接所有的草，砍断每条边的费用是d，t连接所有的洞，砍断每条费用是f，然后相邻的草和草之间连上边，相邻的洞和洞之间连上边；

现在要是想隔断s和t，隔断s和t的最小割就是问题的答案了，为什么这么说呢？

首先，考虑将草和洞之间的边全部都隔断，相当于是给草和洞之间加了围栏，此时的割值就是总费用；

但其实也可以把某个草变成洞，比如把图中红色的草变成了洞，那么就隔断s到红色点，这样一来，从红色点连到洞上的线就不需要割断了（毕竟从s到红色的点的线都断了），但是，这样并不能万事大吉，这样黑色的线是断了，但蓝色的线还可以到红色点，这对应的就是原来的草变成了洞，所以相邻的草指向刚变成的洞的流也要隔断，因此还要隔断所有蓝色的线；

同理，由洞到t点的线也可以隔断，相当于是把一个洞填上了草。

这样，只需要知道最小割，最小割对应的值就是答案，求最小割用Dicnic；

但还要注意一点，就是由s点连向最外围四周的草的费用应为inf，为什么呢？因为四周必须是草，隔断一条这样的边（即把一个外围的草变成洞）是不允许的，我们就让他的代价会非常非常大。（注意是连上费用为inf的边，而不是不连，在割的问题里不连相当于隔断这条边毫无开销）

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
#define mem(a,x) memset(a,x,sizeof(a))
#define Rep(i,x,n)  for(int i= x;i<=n;i++)
using namespace std;
const int maxn = 3000;
const int inf = 100000000;
char mp[55][55];
struct Edge
{
    int from,to,cap,flow;
};
int drx[]={-1,1,0,0};
int dry[]={0,0,-1,1};
struct Dicnic
{
    int n,m,s,t;
    int d[maxn],cur[maxn],vis[maxn];
    vector<Edge>edges;
    vector<int>G[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)
    {
        Edge e1 = {from,to,cap,0};
        Edge e2 = {to,from,0,0};
        edges.push_back(e1);
        edges.push_back(e2);
        int m = edges.size();
        G[from].push_back(m-2);
        G[to].push_back(m-1);
    }


    bool BFS()
    {
        mem(vis,0);
        queue<int >Q;
        vis[s] = 1;
        d[s] = 0;
        Q.push(s);
        while(!Q.empty()){
            int x = Q.front();  Q.pop();
            for(int i= 0;i<G[x].size();i++){
                Edge &e = edges[G[x][i]];
                if(!vis[e.to]&&e.cap>e.flow){
                    d[e.to] = d[x] + 1;
                    vis[e.to] = 1;
                    Q.push(e.to);
                }
            }
        }
        return vis[t];
    }


    int DFS(int x,int a)
    {
        if(x==t||a==0)  return a;
        int f,flow = 0;
        for(int &i= cur[x];i<G[x].size();i++){
            Edge &e = edges[G[x][i]];
            if(d[e.to] == d[x]+1&&(f=(DFS(e.to,min(e.cap-e.flow,a))))>0){
                flow += f;
                a -= f;
                e.flow += f;
                edges[G[x][i]^1].flow -= f;
                if(a==0)    break;
            }
        }
        return flow;
    }


    int MaxFlow(int s,int t)
    {
        this -> s = s;  this -> t = t;
        int flow = 0;
        while(BFS()){
            mem(cur,0);
            flow += DFS(s,inf);
        }
        return flow;
    }
};
Dicnic g;
int main()
{
    int T,w,h,d,f,b;
    scanf("%d",&T);
    while(T--){
        scanf("%d %d %d %d %d",&w,&h,&d,&f,&b);
        for(int i = 1;i<= h;i++){
            scanf("%s",mp[i]+1);
        }
        int ans = 0;
        for(int i = 1;i<=w;i++){
            if(mp[1][i]=='.'){
                ans += f;
                mp[1][i]='#';
            }
            if(mp[h][i]=='.'){
                ans += f;
                mp[h][i] = '#';
            }
        }
        for(int i= 2;i<=h-1;i++){
            if(mp[i][1]=='.'){
                ans += f;
                mp[i][1] = '#';
            }
            if(mp[i][w]=='.'){
                ans += f;
                mp[i][w] = '#';
            }
        }                                   ///啰里啰嗦一大段为的就是把四周的洞变成草，并且加上变成草的费用；
        g.init(w*h+1);
        for(int i=1;i<=h;i++){
            for(int j= 1;j<=w;j++){
                int id1 = w*(i-1) + j , id2;
                if(mp[i][j]=='#'&&i!=1&&i!=h&&j!=1&&j!=w)   g.AddEdge(0,id1,d);
                else if(mp[i][j]=='#'&&(i==1||i==h||j==1||j==w))   g.AddEdge(0,id1,inf);  ///这个判断十分重要；
                else                g.AddEdge(id1,w*h+1,f);
                for(int k = 0;k<4;k++){
                    int x = i+drx[k],y = j+dry[k];
                    if(x>=1&&x<=h&&y>=1&&y<=w){
                        id2 = w*(x-1)+y;
                        g.AddEdge(id1,id2,b);
                    }
                }
            }
        }
        ans += g.MaxFlow(0,w*h+1);
        printf("%d\n",ans);
    }
    return 0;
}