题目大意：给出一个 n ∗ m n*m n∗m 的矩阵，每个格子都有两个权值 a a a 和 b b b，分别代表花费和收益。一个格子被占，当且仅当：
- 格子上有人
- 格子的上下左右都有人
格子被占可以获得收益 b b b，格子上有人需要花费 a a a，问如何分配可以使得收益最高。
题目分析：很经典，但我不会的一个模型。
拆点最小割，首先棋盘问题不难想到奇偶拆点，在此基础上将每个点再拆一下用来维护
b
b
b，再加点无穷大的边用来调和
a
a
a：
上图中
x
1
x_1
x1 和
x
2
x_2
x2 是奇数点的入点和出点，
y
1
y_1
y1 和
y
2
y_2
y2 是偶数点的入点和出点。
那么此时最小割就只有三种情况：
- 割掉 s t − x 1 st-x_1 st−x1：选择点 x x x
- 割掉 y 2 − e d y_2-ed y2−ed：选择点 y y y
- 割掉 x 1 − x 2 x_1-x_2 x1−x2 和 y 1 − y 2 y_1-y_2 y1−y2：两个点都不选
不难看出，上述三种情况实质上对应着本题的两个条件，也就是对于某个点，获得 b b b 时的两种情况：
- 割掉某个点本身的 a a a
- 割掉某个点四周的 a a a
所以最后用 ∑ b \sum b ∑b 减去最小割就是最大的答案了。
代码：
// #pragma GCC optimize(2)
// #pragma GCC optimize("Ofast","inline","-ffast-math")
// #pragma GCC target("avx,sse2,sse3,sse4,mmx")
#include<iostream>
#include<cstdio>
#include<string>
#include<ctime>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<stack>
#include<climits>
#include<queue>
#include<map>
#include<set>
#include<sstream>
#include<cassert>
#include<bitset>
#include<list>
#include<unordered_map>
#define lowbit(x) (x&-x)
using namespace std;
typedef long long LL;
typedef unsigned long long ull;
template<typename T>
inline void read(T &x)
{
T f=1;x=0;
char ch=getchar();
while(0==isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
while(0!=isdigit(ch)) x=(x<<1)+(x<<3)+ch-'0',ch=getchar();
x*=f;
}
template<typename T>
inline void write(T x)
{
if(x<0){x=~(x-1);putchar('-');}
if(x>9)write(x/10);
putchar(x%10+'0');
}
const int inf=0x3f3f3f3f;
const int N=4100;
template<typename T>
struct Dinic
{
const static int N=4100;
const static int M=N*N;
const T inf=0x3f3f3f3f3f3f3f3f;
struct Edge
{
int to,next;
T w;
}edge[M];//边数
int head[N],cnt;
void addedge(int u,int v,T w)
{
edge[cnt].to=v;
edge[cnt].w=w;
edge[cnt].next=head[u];
head[u]=cnt++;
edge[cnt].to=u;
edge[cnt].w=0;//反向边边权设置为0
edge[cnt].next=head[v];
head[v]=cnt++;
}
int d[N],now[N];//深度 当前弧优化
bool bfs(int s,int t)//寻找增广路
{
memset(d,0,sizeof(d));
queue<int>q;
q.push(s);
now[s]=head[s];
d[s]=1;
while(!q.empty())
{
int u=q.front();
q.pop();
for(int i=head[u];i!=-1;i=edge[i].next)
{
int v=edge[i].to;
T w=edge[i].w;
if(d[v])
continue;
if(!w)
continue;
d[v]=d[u]+1;
now[v]=head[v];
q.push(v);
if(v==t)
return true;
}
}
return false;
}
T dinic(int x,int t,T flow)//更新答案
{
if(x==t)
return flow;
T rest=flow,i;
for(i=now[x];i!=-1&&rest;i=edge[i].next)
{
int v=edge[i].to;
T w=edge[i].w;
if(w&&d[v]==d[x]+1)
{
T k=dinic(v,t,min(rest,w));
if(!k)
d[v]=0;
edge[i].w-=k;
edge[i^1].w+=k;
rest-=k;
}
}
now[x]=i;
return flow-rest;
}
void init()
{
memset(now,0,sizeof(now));
memset(head,-1,sizeof(head));
cnt=0;
}
T solve(int st,int ed)
{
T ans=0,flow;
while(bfs(st,ed))
while(flow=dinic(st,ed,inf))
ans+=flow;
return ans;
}
};
Dinic<int>t;
const int b[4][2]={0,1,0,-1,1,0,-1,0};
int id[50][50][2],tot;
int main()
{
#ifndef ONLINE_JUDGE
// freopen("data.in.txt","r",stdin);
// freopen("data.out.txt","w",stdout);
#endif
// ios::sync_with_stdio(false);
t.init();
int n,m,st=N-1,ed=st-1,sum=0;
read(n),read(m);
for(int i=1;i<=n;i++) {
for(int j=1;j<=m;j++) {
for(int k=0;k<2;k++) {
id[i][j][k]=++tot;
}
}
}
for(int i=1;i<=n;i++) {
for(int j=1;j<=m;j++) {
int a;
read(a);
if((i+j)&1) t.addedge(st,id[i][j][0],a);
else t.addedge(id[i][j][1],ed,a);
}
}
for(int i=1;i<=n;i++) {
for(int j=1;j<=m;j++) {
int b;
read(b);
t.addedge(id[i][j][0],id[i][j][1],b);
sum+=b;
}
}
for(int x=1;x<=n;x++) {
for(int y=1;y<=m;y++) {
if((x+y)&1) {
for(int k=0;k<4;k++) {
int xx=x+b[k][0],yy=y+b[k][1];
if(xx<=0||xx>n||yy<=0||yy>m) continue;
for(int i=0;i<2;i++) t.addedge(id[x][y][i],id[xx][yy][i],inf);
}
}
}
}
cout<<sum-t.solve(st,ed)<<endl;
return 0;
}