BZOJ4439——[Swerc2015]Landscaping

0、题目：

FJ有一块N*M的矩形田地，有两种地形高地（用‘#’表示）和低地（用‘.’表示）

FJ需要对每一行田地从左到右完整开收割机走到头，再对每一列从上到下完整走到头，如下图所示

 

对于一个4*4的田地，FJ需要走8次。

收割机是要油的，每次从高地到低地或从低地到高地需要支付A的费用。

但是FJ有黑科技，可以高地与低地的互变，都只需要一个支付B的费用。

询问FJ需要支付最小费用。

1、分析：这题考试的时候没有看懂，英语太垃圾了。。。。考完发现bzoj上有翻译QAQ

然后这就是个智障题了QAQ...我们对于所有的低处，从源点连一波长度是B的边

然后所有的高处，连一波边到汇点，长度是B。。。

然后对于相邻的点连一波边，边权是A，啊。。为啥低处要连向低处。。

原因就是最小割吗。。。需要确定S集和T集。。。

#include <queue>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
using namespace std;
#define M 100010
#define inf 1014748364

inline int read(){
    char ch = getchar(); int x = 0, f = 1;
    while(ch < '0' || ch > '9'){
        if(ch == '-') f = -1;
        ch = getchar();
    }
    while('0' <= ch && ch <= '9'){
        x = x * 10 + ch - '0';
        ch = getchar();
    }
    return x * f;
}

namespace dinic{
    struct Edge{
        int from, to, cap, flow, next;
    } G[M];
    int head[M], cur[M], tot;
    int vis[M], d[M];
    int s, t;

    inline void init(){
        memset(head, -1, sizeof(head));
        tot = -1;
    }

    inline void add(int u, int v, int w){
        G[++ tot] = (Edge){u, v, w, 0, head[u]};
        head[u] = tot;
        G[++ tot] = (Edge){v, u, 0, 0, head[v]};
        head[v] = tot;
    }

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

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

    inline int maxflow(){
        int flow = 0;
        while(BFS()){
            for(int i = s; i <= t; i ++) cur[i] = head[i];
            flow += DFS(s, inf);
        }
        return flow;
    }
}

char str[60][60];
int num[60][60];
int cnt;
int dx[] = {0, 1, -1, 0};
int dy[] = {1, 0, 0, -1};
int n, m, A, B;

inline bool is_(int x, int y){
    return x < 1 || y < 1 || x > n || y > m;
}

int main(){
    n = read(), m = read(), A = read(), B = read();
    for(int i = 1; i <= n; i ++) scanf("%s", str[i] + 1);
    for(int i = 1; i <= n; i ++){
        for(int j = 1; j <= m; j ++){
            num[i][j] = ++ cnt;
        }
    }
    dinic::init();
    dinic::s = 0; dinic::t = n * m + 1;
    for(int i = 1; i <= n; i ++){
        for(int j = 1; j <= m; j ++){
            if(str[i][j] == '.') dinic::add(0, num[i][j], B);
            else dinic::add(num[i][j], n * m + 1, B);
            for(int k = 0; k < 4; k ++){
                int tx = i + dx[k], ty = j + dy[k];
                if(is_(tx, ty)) continue;
                dinic::add(num[i][j], num[tx][ty], A);
            }
        }
    }
    printf("%d\n", dinic::maxflow());
    return 0;
}