链接Click Here
这个题就是个板子的最小割多选一模型啦(QwQ)，这里介绍一种通用的解法。
抛开组合收益不谈，这个题就是一个简单的最小割模型。我们只需要建出来这样一张图，在上面跑最小割，割掉的就是不用的，留下来的就是最大收益啦(≧▽≦)/，是不是很显然呢？
如果要考虑组合收益的话，我们把这个组合收益实体化成一个点来进行处理。还是上面那个图，我们假设(2), (3)是以和(1)四连通的两个点。这样的话我们需要保证一件事情：
-
在(art_1, art_2, art_3)中，只要有一个被割掉（不选），那么(art)的组合收益就同时被割掉。
-
在(sci_1, sci_2, sci_3)中，只要有一个被割掉（不选），那么(sci)的组合收益就同时被割掉。
根据这些要求，我们建出来了下面这样的一张图。
很显然，这张图是可以满足上面的性质的。我们这样连边来看一下。
-
(s -> art\_same(i, j)) (flow = art\_ex[i][j])
-
(art\_same(i, j) -> linked\_nodes) (flow = INFF)
思考一下，假如我们割掉了(art)中的任意一个，那么(sci)那边一定有对应的边没有割掉，这样我们的(art\_same[1])就会顺着没有被割掉的边流走啦(QwQ)(也就是还是被割掉了(QwQ))
同理，理科那边和更多点的情况，这种图都是适用的。
关键需要注意的一件事情：在建图的时候，因为可能会出现(art\_same[i])太大而另外一边的流量太小，无法完全割断的情况，我们要给它加上一个(INF)，在最后求和的时候再减掉。而且这个(INF)一定要低于(INFF)的数量级，中间的边一定要保证是不能割掉的！这一点相当重要。
这种图是一种非常重要的最小割模型图，一定要会啊(QwQ)
#include <bits/stdc++.h>
#define N 30100
#define M 480010
#define int long long
using namespace std;
const int INF = 0x3f3f3f3f;
const int INFF = 0x3f3f3f3f3f3f3f3fll;
int n, m, art[105][105], sci[105][105];
int art_ex[105][105], sci_ex[105][105];
int node (int x, int y) {return (x - 1) * m + y;}
int same_art (int x, int y) {return n * m * 1 + node (x, y);}
int same_sci (int x, int y) {return n * m * 2 + node (x, y);}
int mv[5][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
bool in_map (int x, int y) {
return 1 <= x && x <= n && 1 <= y && y <= m;
}
int cnt = -1, head[N];
struct edge {
int nxt, to, f;
}e[M];
void add_edge (int from, int to, int flw) {
e[++cnt].nxt = head[from];
e[cnt].to = to;
e[cnt].f = flw;
head[from] = cnt;
}
queue <int> q;
#define fpop(x) x.front();x.pop()
int cur[N], deep[N];
bool bfs (int s, int t) {
memcpy (cur, head, sizeof (head));
memset (deep, 0x3f, sizeof (deep));
deep[s] = 1; q.push (s);
while (!q.empty ()) {
int u = fpop (q);
for (int i = head[u]; ~i; i = e[i].nxt) {
int v = e[i].to;
if (e[i].f && deep[v] == INFF) {
deep[v] = deep[u] + 1;
q.push (v);
}
}
}
return deep[t] != INFF;
}
int dfs (int u, int t, int lim) {
if (u == t || !lim) {
return lim;
}
int tmp = 0, flow = 0;
for (int &i = cur[u]; ~i; i = e[i].nxt) {
int v = e[i].to;
if (deep[v] == deep[u] + 1) {
tmp = dfs (v, t, min (lim, e[i].f));
lim -= tmp;
flow += tmp;
e[i ^ 0].f -= tmp;
e[i ^ 1].f += tmp;
if (!lim) break;
}
}
return flow;
}
int Dinic (int s, int t) {
int min_cut = 0;
while (bfs (s, t)) {
min_cut += dfs (s, t, INFF);
}
return min_cut;
}
signed main () {
memset (head, -1, sizeof (head));
cin >> n >> m;
int s = n * m * 3 + 1, t = n * m * 3 + 2;
for (int i = 1; i <= n; ++i) for (int j = 1; j <= m; ++j) cin >> art[i][j];
for (int i = 1; i <= n; ++i) for (int j = 1; j <= m; ++j) cin >> sci[i][j];
for (int i = 1; i <= n; ++i) for (int j = 1; j <= m; ++j) cin >> art_ex[i][j];
for (int i = 1; i <= n; ++i) for (int j = 1; j <= m; ++j) cin >> sci_ex[i][j];
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
add_edge (s, node (i, j), art[i][j]); add_edge (node (i, j), s, 0);
add_edge (node (i, j), t, sci[i][j]); add_edge (t, node (i, j), 0);
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
add_edge (s, same_art (i, j), art_ex[i][j]); add_edge (same_art (i, j), s, 0);
add_edge (same_sci (i, j), t, sci_ex[i][j]); add_edge (t, same_sci (i, j), 0);
for (int k = 0; k < 5; ++k) {
int tx = i + mv[k][0], ty = j + mv[k][1];
if (in_map (tx, ty)) {
add_edge (same_art (i, j), node (tx, ty), INFF); add_edge (node (tx, ty), same_art (i, j), 0);
add_edge (node (tx, ty), same_sci (i, j), INFF); add_edge (same_sci (i, j), node (tx, ty), 0);
}
}
}
}
int ans = 0;// n * m * INF;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
ans += art[i][j] + sci[i][j] + art_ex[i][j] + sci_ex[i][j];
}
}
cout << ans - Dinic (s, t) << endl;
}