方格取数 【网络流24题】【最小割】

输入输出样例

输入 #1复制

3 3
1 2 3
3 2 3
2 3 1 

输出 #1复制

11

思路

　　因为要保证一个点不能和他有共同边的点接触

　　很容易想到把所有点划分为两个阵营

　　显然一个横纵坐标相加为偶数的点

　　其所接触的点横纵坐标相加为奇数

　　于是得到二分图划分的依据：横纵坐标相加和的奇偶性

　　把偶数阵营连边S，奇数阵营连边T

　　奇偶阵营之间连边 INF

　　就是本踢的二分图模型

　　通过观察可以发现，图中向S、T连边象征了一种抉择

　　当两个有公共边的点可以流通时，显然是不满足要求的

　　考虑删除这种边且使得花费最小

　　发现这是个最小割问题

　　通过在相邻点之间连流量为 inf 的边可以保证割去的一定是某个点连向 S 或 T 的边

　　这个时候答案就等于所有点的总权值和 - 最小割 = SUM  - MAXFLOW

CODE

#include <bits/stdc++.h>
#define dbg(x) cout << #x << "=" << x << endl
#define eps 1e-8
#define pi acos(-1.0)

using namespace std;
typedef long long LL;

const LL inf = 0x7f7f7f7f;

template<class T>inline void read(T &res)
{
    char c;T flag=1;
    while((c=getchar())<'0'||c>'9')if(c=='-')flag=-1;res=c-'0';
    while((c=getchar())>='0'&&c<='9')res=res*10+c-'0';res*=flag;
}

namespace _buff {
    const size_t BUFF = 1 << 19;
    char ibuf[BUFF], *ib = ibuf, *ie = ibuf;
    char getc() {
        if (ib == ie) {
            ib = ibuf;
            ie = ibuf + fread(ibuf, 1, BUFF, stdin);
        }
        return ib == ie ? -1 : *ib++;
    }
}

int qread() {
    using namespace _buff;
    int ret = 0;
    bool pos = true;
    char c = getc();
    for (; (c < '0' || c > '9') && c != '-'; c = getc()) {
        assert(~c);
    }
    if (c == '-') {
        pos = false;
        c = getc();
    }
    for (; c >= '0' && c <= '9'; c = getc()) {
        ret = (ret << 3) + (ret << 1) + (c ^ 48);
    }
    return pos ? ret : -ret;
}

const int maxn = 200007;

int n, m;
int s, t;

struct edge{
    int from,to;
    LL cap,flow;
};

struct DINIC {
    int head[maxn << 1], nxt[maxn << 1], edge[maxn << 1], cnt;
    int cap[maxn << 1], depth[maxn << 1];

    void init() {
        cnt = 1;
        memset(head, 0, sizeof(head));
    }

    void BuildGraph(int u, int v, int w) {
        ++cnt;
        edge[cnt] = v;
        nxt[cnt] = head[u];
        cap[cnt] = w;
        head[u] = cnt;

        ++cnt;
        edge[cnt] = u;
        nxt[cnt] = head[v];
        cap[cnt] = 0;
        head[v] = cnt;
    }

    queue<int> q;

    bool bfs() {
        memset(depth, 0, sizeof(depth));
        depth[s] = 1;
        q.push(s);
        while(!q.empty()) {
            int u = q.front();
            q.pop();
            for ( int i = head[u]; i; i = nxt[i] ) {
                int v = edge[i];
                if(depth[v]) {
                    continue;
                }
                if(cap[i]) {
                    depth[v] = depth[u] + 1;
                    q.push(v);
                }
            }
        }
        //printf("dep[%d]:%d
",t, depth[t]);
        return depth[t];
    }

    int dfs(int u, int dist) {
        if(u == t) {
            return dist;
        }
        int flow = 0;
        for ( int i = head[u]; i && dist; i = nxt[i] ) {
            if(cap[i] == 0)
                continue;
            int v = edge[i];
            if(depth[v] != depth[u] + 1) {
                continue;
            }
            int res = dfs(v, min(cap[i], dist));
            cap[i] -= res;
            cap[i ^ 1] += res;
            //printf("cap[%d]:%d
",t, cap[t]);
            dist -= res;
            flow += res;
        }
        return flow;
    }

    int maxflow() {
        int ans = 0;
        while(bfs()) {
            ans += dfs(s, inf);
        }
        return ans;
    }
} dinic;

int dr[4] = {1, 0, -1, 0};
int dc[4] = {0, 1, 0, -1};

inline int id(int a, int b) {
    return (a - 1) * n + b;
}

int main()
{
    //freopen("data.txt", "r", stdin);
    read(m); read(n);
    int sum = 0;
    s = 0, t = n * m + 1;
    dinic.init();
    for ( int i = 1; i <= m; ++i ) {
        for ( int j = 1; j <= n; ++j ) {
            int x;
            read(x);
            sum += x;
            if(((i + j) & 1) == 0) {
                dinic.BuildGraph(s, id(i, j), x);
                for ( int k = 0; k < 4; ++k ) {
                    int xx = i + dr[k], yy = j + dc[k];
                    if(xx <= m && xx >= 1 && yy <= n && yy >= 1) {
                        dinic.BuildGraph(id(i, j), id(xx, yy), inf);
                    }
                    
                }
            }
            else {
                dinic.BuildGraph(id(i, j), t, x);
            }
        }
    }
    int res = dinic.maxflow();
    //dbg(res);
    cout << sum - res << endl;
    return 0;
}