Uva1515 Pool construction 最小割

$Uva1515$
题意：
对于一个字符矩阵，有$\#$和$.$两种字符，分别代表草和洞。相邻草和洞需要建立栅栏，草和洞可以互相转化通过一定的花费。求最小花费。
题解:
我们考虑分割，想到"割"这个概念。
类似于之前最大闭合子权图的概念，割的应用一般出现：可选可不选的费用上，选择了割就是不选择这个费用。
对于这道题，同理，我们需要满足的是：草源点无法通达到洞汇点。(也就是建立了围墙)
对于已有的草和洞，分别连接。如果需要转换，就把连接的边割掉(普通的建图)。

唯一要维护的相邻关系，对相邻各自建立双向边(因为可能草洞选择互换)。但是不能重复建边(影响连通：需要$map$记录以及创建的边)。

需要注意的是：边缘必须是草：预处理即可，并且不能割掉这些边(设置为$inf$)

初始图：不算上源点和汇点。

选择好了草和洞的转换的点，同时加上了相邻边。
对于上面的草部分，中间是否有相邻边不会影响连通(右边以及被割了)。
同理，下面也是(我没画
但是草到洞的相邻边必须割掉：可以连通。

这是一道最小割的完美应用题，值得学习。

#include<bits/stdc++.h>
#define FOR(i,a,b) for(int i=a;i<=b;i++)
#define inf 0x3f3f3f3f3f3f3f3f
#define ll long long
using namespace std;

const int maxn = 2505;
string str[maxn];

int X[]={1,-1,0,0};
int Y[]={0,0,1,-1};

struct Edge{
    int from,to;
    ll cap,flow;
};

map<pair<int,int>,int>M;

struct Dinic{
    int n,tmp,s,t;
    vector<Edge>edges;
    vector<int>G[maxn];//邻接表用，存储的是边在edges中的序号
    bool vis[maxn];//BFS使用
    int d[maxn];//从起点到i的距离
    int cur[maxn];//当前弧下标

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

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

    bool BFS(){
        memset(vis,0,sizeof(vis));
        queue<int>q;
        q.push(s);
        d[s]=0,vis[s]=1;
        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){
                    vis[e.to]=1;
                    d[e.to]=d[x]+1;
                    q.push(e.to);
                }//只考虑残量网络中的弧
            }
        }
        return vis[t];//用于判断是否能走到底。
    }

    ll DFS(int x,ll a){//多路增广
        if(x==t||a==0)return a;//a表示的是当前最小，也就是接下来能用的不能超过a
        ll flow=0,f;
        for(int& i=cur[x];i<G[x].size();i++){//能保证一个dfs中不重复走同样的边(对于同一个节点)，因为走过的边一定是满载的了。
            Edge& e = edges[G[x][i]];
            if(d[x]+1==d[e.to]&&(f=DFS(e.to,min(a,e.cap-e.flow)))>0){
                e.flow+=f;
                edges[G[x][i]^1].flow-=f;
                flow+=f;
                a-=f;
                if(a==0)break;//f表示从这个e.to的点开始使用的最大流。
            }
        }
        return flow;
    }

    ll Maxflow(){
        ll flow=0;
        while(BFS()){
            memset(cur,0,sizeof(cur));
            flow+=DFS(s,inf);
        }
        return flow;
    }
}dc;

int main(){
    int T,d,f,b;
    cin>>T;
    while(T--){
        M.clear();
        int r,c;
        scanf("%d%d",&c,&r);
        scanf("%d%d%d",&d,&f,&b);
        dc.init(r*c+2,r*c+1,r*c+2);
        for(int i=1;i<=r;i++)cin>>str[i];
        ll ans=0;
        for(int i=1;i<=r;i++){
            for(int j=1;j<=c;j++){
                //cout<<i<<" "<<j<<endl;
                for(int k=0;k<4;k++){
                    int xx=i+X[k],yy=j+Y[k];
                    if((xx>=1&&xx<=r)&&(yy>=1&&yy<=c)&&(!M[make_pair((i-1)*c+j,(xx-1)*c+yy)])){
                        dc.AddEdge((i-1)*c+j,(xx-1)*c+yy,(ll)b);
                        M[make_pair((i-1)*c+j,(xx-1)*c+yy)]=1;
                    }
                }
                if(i==1||i==r||j==1||j==c){
                    if(str[i][j-1]=='.')ans+=(ll)f;
                    dc.AddEdge(r*c+1,(i-1)*c+j,inf);
                    continue;
                }
                if(str[i][j-1]=='#'){
                    dc.AddEdge(r*c+1,(i-1)*c+j,(ll)d);
                }
                if(str[i][j-1]=='.'){
                    dc.AddEdge((i-1)*c+j,r*c+2,(ll)f);
                }
            }
        }
        //cout<<ans<<endl;
        cout<<ans+dc.Maxflow()<<endl;
    }
}