Libre 6007 「网络流 24 题」方格取数 / Luogu 2774 方格取数问题（网络流，最大流）

Description

在一个有 m*n 个方格的棋盘中，每个方格中有一个正整数。现要从方格中取数，使任意 2 个数所在方格没有公共边，且取出的数的总和最大。试设计一个满足要求的取数算法。对于给定的方格棋盘，按照取数要求编程找出总和最大的数。

Input

第 1 行有 2 个正整数 m 和 n，分别表示棋盘的行数和列数。接下来的 m 行，每行有 n 个正整数，表示棋盘方格中的数。

Output

程序运行结束时，将取数的最大总和输出

Sample Input

3 3
1 2 3
3 2 3
2 3 1

Sample Output

Http

Libre:https://loj.ac/problem/6007
Luogu:https://www.luogu.org/problem/show?pid=2774

Source

网络流，最大流

解决思路

~~总觉的这道题能想到用网络流解很玄学~~
网络流的另外一种模型：点覆盖模型，就是有诸如两个只能选一个的限制这类，没有做过的话根本想不到。
我们把网格黑白染色，让黑格周围都是白格，白格同理，简单点来说对于格子(i,j)，若i%2==j%2则黑色，否则白色。
另外建立一个源点一个汇点。对于每一个黑色的格子，从源点连一条容量为格子上的数的边，并且向周围的所有相邻白格子连一条容量为无穷大的边。对于每一个白格子，从白格子连一条容量位格子上的数的边到汇点。
同时，统计所有格子上的数之和记为sum。求出最大流flow，则答案就是flow-sum。
这种解法的原理是基于最小割最大流，由于笔者知识水平不高，暂且不知道如何证明。但可以通过画图手动模拟的方式基本上可以认识到其正确性，即通过巧妙的方式割去其中部分边点，使得剩下的最大（笔者也只能理解到这里了）
另：这里使用Dinic实现最大流，具体可以移步我的这篇文章

代码

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
using namespace std;

#define pos(x,y) (x-1)*n+y

const int maxN=40;
const int inf=2147483647;

class Edge
{
public:
	int u,v,flow;
};

int n,m;
int cnt=-1;
int Mat[maxN][maxN];
int Head[maxN*maxN];
int Next[maxN*maxN*maxN*maxN];
Edge E[maxN*maxN*maxN*maxN];
int depth[maxN*maxN];
int cur[maxN*maxN];
int Q[maxN*maxN*maxN];

void Add_Edge(int u,int v,int flow);
bool bfs();
int dfs(int u,int flow);

int main()
{
	memset(Head,-1,sizeof(Head));
	int sum=0;
	scanf("%d%d",&m,&n);
	for (int i=1;i<=m;i++)
		for (int j=1;j<=n;j++)
		{
			int num;
			scanf("%d",&num);
			sum+=num;//sum统计所有格子的权之和
			if (i%2==j%2)//若为黑格子
			{
				Add_Edge(0,pos(i,j),num);//连接源点
				if (i!=1)//分别连接四周的白格子，注意判断存在与否
					Add_Edge(pos(i,j),pos(i-1,j),inf);
				if (i!=m)
					Add_Edge(pos(i,j),pos(i+1,j),inf);
				if (j!=1)
					Add_Edge(pos(i,j),pos(i,j-1),inf);
				if (j!=n)
					Add_Edge(pos(i,j),pos(i,j+1),inf);
			}
			else
				Add_Edge(pos(i,j),n*m+1,num);//若为白格子，则只连接汇点
		}
	int Ans=0;
	while (bfs())//求解最大流
	{
	    memcpy(cur,Head,sizeof(cur));
		while (int di=dfs(0,inf))
			Ans+=di;
	}
	cout<<sum-Ans<<endl;
	return 0;
}

void Add_Edge(int u,int v,int flow)
{
	cnt++;
	Next[cnt]=Head[u];
	Head[u]=cnt;
	E[cnt].u=u;
	E[cnt].v=v;
    E[cnt].flow=flow;

	cnt++;
	Next[cnt]=Head[v];
	Head[v]=cnt;
	E[cnt].u=v;
	E[cnt].v=u;
	E[cnt].flow=0;
}

bool bfs()
{
	memset(depth,-1,sizeof(depth));
	int h=1,t=0;
	Q[1]=0;
	depth[0]=1;
	do
	{
		t++;
		int u=Q[t];
		for (int i=Head[u];i!=-1;i=Next[i])
		{
			int v=E[i].v;
			if ((E[i].flow>0)&&(depth[v]==-1))
			{
				h++;
				Q[h]=v;
				depth[v]=depth[u]+1;
			}
		}
	}
	while (t!=h);
	if (depth[n*m+1]==-1)
		return 0;
	return 1;
}

int dfs(int u,int flow)
{
	if (u==n*m+1)
		return flow;
	for (int i=Head[u];i!=-1;i=Next[i])
	{
		int v=E[i].v;
		if ((E[i].flow>0)&&(depth[v]==depth[u]+1))
		{
			int di=dfs(v,min(flow,E[i].flow));
			if (di>0)
			{
				E[i].flow-=di;
				E[i^1].flow+=di;
				return di;
			}
		}
	}
	return 0;
}