题意

给定一个正整数矩阵，可以选取所有四向不邻的数，求和的最大值

sol

将问题转化为在正整数矩阵中移除一些数，使得剩余的所有数四向不邻，且被删去数最小。可以注意到需要使每一个数的四向对应的数都被删除，这可以对应四个约束关系（形如 $A,B$ 中至少有一个被删除），容易发现，这样的约束关系只会出现在横纵坐标和的奇偶性不同的点上，因此可以据此将所有点分为两部分，这是最小割的经典问题，只需要将所有约束作为边连接两个点，建立超级源点 $S$ 连接左部点，右部点连接超级汇点 $T$（容量均为对应贡献），计算最小割即可。
最后答案即为数的总和 - 最小割

代码

#include <iostream>
#include <algorithm>
#include <cstring>
#include <queue>

using namespace std;

const int N = 10005, M = 200005, K = 105, INF = 0x3f3f3f3f;

int h[N], e[M], cap[M], ne[M], idx;
int d[N], cur[N];
int nn, m;
int n, S, T;
int a[K][K];

void add(int a, int b, int c ){
    e[idx] = b, cap[idx] = c, ne[idx] = h[a], h[a] = idx ++ ;
    e[idx] = a, cap[idx] = 0, ne[idx] = h[b], h[b] = idx ++ ;
}

void build(){
    memset(h, -1, sizeof h);
    n = nn * m + 2;
    S = n - 1, T = n;
    for (int i = 1; i <= nn; i ++ )
        for (int j = 1; j <= m; j ++ ) {
            int id = (i - 1) * m + j;
            if ((i % 2) ^ (j % 2)) {
                add(S, id, a[i][j]);
                if (i != 1) add(id, id - m, INF);
                if (i != nn) add(id, id + m, INF);
                if (j != 1) add(id, id - 1, INF);
                if (j != m) add(id, id + 1, INF);
            }
            else add(id, T, a[i][j]);
        }
}

bool bfs(){
    memset(d, -1, sizeof d);
    queue<int> q;
    q.push(S), d[S] = 0, cur[S] = h[S];
    while (!q.empty()) {
        int t = q.front();
        q.pop();
        for(int i = h[t]; ~i; i = ne[i]){
            int j = e[i];
            if (d[j] == -1 && cap[i]) {
                cur[j] = h[j];
                d[j] = d[t] + 1;
                if (j == T) return true;
                q.push(j);
            }
        }
    }
    return false;
}

int find(int u, int limit){
    if (u == T) return limit;
    int flow = 0;
    for (int i = cur[u]; ~i && flow < limit; i = ne[i]){
        int j = e[i];
        cur[u] = i;
        if (d[j] == d[u] + 1 && cap[i]){
            int t = find(j, min(cap[i], limit - flow));
            if (!t) d[j] = -1;
            cap[i] -= t, cap[i ^ 1] += t, flow += t;
        }
    }
    return flow;
}

int dinic(){
    int r = 0, flow;
    while (bfs()) while (flow = find(S, INF)) r += flow;
    return r;
}

int main(){
    scanf("%d%d", &nn, &m);
    int sum = 0;
    for (int i = 1; i <= nn; i ++ ) 
        for (int j = 1; j <= m; j ++ ) scanf("%d", &a[i][j]), sum += a[i][j];
    build();
    printf("%d\n", sum - dinic());
}