【网络流二十四题 方格取数问题】【二分图点权最大独立集->最小割】

问题模型： 二分图点权最大独立集
转化模型：最小割

建图

首先把棋盘黑白染色，使相邻格子颜色不同，所有黑色格子看做二分图 X 集合中顶点，白色格子看做 Y 集合顶点，建立附加源 S 汇 T。

1. 从 S 向 X 集合中每个顶点连接一条容量为格子中数值的有向边。
2. 从 Y 集合中每个顶点向 T 连接一条容量为格子中数值的有向边。
3. 相邻黑白格子 Xi, Yj 之间从 Xi 向 Yj 连接一条容量为无穷大的有向边。
   Q：为什么是连一条容量为 inf 的边呢？
   A：对于一条 S - Xi - Yi - T 的路径，因为点覆盖集中的点在图中相应的带权边组成一个简单割，而简单割只与 S 或 T 相关联（一个点如果是一条边的顶点之一，则称为该点与该边关联），与 Xi->Yi 的边无关，我们一定不能让 Xi->Yi 的边被割，所以直接设 Xi->Yi 边容量为 inf 即可。

求出网络最大流，要求的结果就是所有格子中数值之和减去最大流量。

–

这是一个二分图最大点权独立集问题，就是找出图中一些点，使得这些点之间没有边相连，这些点的权值之和最大。独立集与覆盖集是互补的，求最大点权独立集可以转化为求最小点权覆盖集（最小点权支配集）。最小点权覆盖集问题可以转化为最小割问题解决。

结论：最大点权独立集 = 所有点权 - 最小点权覆盖集 = 所有点权 - 最小割集 = 所有点权 - 网络最大流。

定义：若一个 S - T 割满足割中的每条边只都与源或汇关联，称该割为简单割。

对于一个网络，除去冗余点（不存在一条 S - T 路径经过的点），每个顶点都在一个从 S 到 T 的路径上。割的性质就是不存在从 S 到 T 的路径，简单割可以认为割边关联的非 S T 节点为割点，而在二分图网络流模型中每个点必关联到一个割点（否则一定还有增广路，当前割不成立），所以一个割集对应了一个覆盖集（支配集）。最小点权覆盖集就是最小简单割，求最小简单割的建模方法就是把 X Y 集合之间的变容量设为无穷大，此时的最小割就是最小简单割了。

#include <bits/stdc++.h>

using namespace std;
const int N = 1e5 + 5, inf = 0x7fffffff;

struct Edge {
    int next, to, c;    
}e[N << 1];

int m, n, tim = 0, s, t;
int a[55][55], number[55][55];
int x[4] = {0, 0, -1, 1}, y[4] = {-1, 1, 0, 0};

int cnt = 1;
int head[N], cur[N];
void add(int u, int v, int c) {
    e[++ cnt].to = v; e[cnt].c = c; e[cnt].next = head[u]; head[u] = cnt;
    e[++ cnt].to = u; e[cnt].c = 0; e[cnt].next = head[v]; head[v] = cnt;
}

int dep[N];
bool bfs(int x) {
    queue<int> q;
    memset(dep, 0, sizeof(dep));
    dep[x] = 1; q.push(x);

    while (!q.empty()) {
        int u = q.front(); q.pop();
        for (int i = head[u]; i; i = e[i].next) {
            int v = e[i].to;
            if (!dep[v] && e[i].c) { dep[v] = dep[u] + 1; q.push(v); }
        }
    }

    if (!dep[t]) return 0;
    return 1;
}

int dfs(int u, int flow) {
    if (u == t) return flow;

    for (int &i = cur[u]; i; i = e[i].next) {
        int v = e[i].to;
        if (dep[v] == dep[u] + 1 && e[i].c) {
            int nowflow = dfs(v, min(flow, e[i].c));
            if (nowflow > 0) {
                e[i].c -= nowflow;
                e[i ^ 1].c += nowflow;
                return nowflow;
            }
        }
    }

    return 0;
}

int Dinic() {
    int res = 0;
    while (bfs(s)) {
        for (int i = s; i <= t; i ++) cur[i] = head[i];
        while (int d = dfs(s, inf)) res += d;
    }
    return res;
}

void color() { // 黑白染色 
    for (int i = 0; i < m; i ++)
        for (int j = i & 1; j < n; j += 2) {
            add(s, number[i][j], a[i][j]);
            for (int k = 0; k < 4; k ++) {
                int xx = i + x[k], yy = j + y[k];
                if (xx >= 0 && xx < m && yy >= 0 && yy < n) add(number[i][j], number[xx][yy], inf);
            }
        }
    for (int i = 0; i < m; i ++)
        for (int j = i & 1 ^ 1; j < n; j += 2)
            add(number[i][j], t, a[i][j]);
}

int main() {
    int sum = 0;
    scanf("%d%d", &m, &n);
    s = 0, t = m * n + 1;
    for (int i = 0; i < m; i ++) {
        for (int j = 0; j < n; j ++) {
            scanf("%d", &a[i][j]);
            sum += a[i][j], number[i][j] = ++ tim;
        }
    }
    color();
    int ans = sum - Dinic();
    printf("%d\n", ans);
    return 0;   
}