题目描述

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

输入格式

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

输出格式

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

输入输出样例

输入 #1

3 3
1 2 3
3 2 3
2 3 1

输出 #1

11

分析

如果将棋盘黑白染色，黑点放左边，白点放右边，每个黑点向相邻的白点连边，会形成一个二分图。
然后每个点都有点权，我们要选择一些点，这些点之间没有边，使得点权最大。
这是二分图的最大独立集问题，就是选出一些点集，每条边至多选择一个点，使得点权和最大。
和它对立的是二分图的最小覆盖集问题，就是选出一些点集，每条边至少选一个点，使得点权和最小。
显然 最大独立集 = V - 最小覆盖集
我们试着求最小覆盖集问题。
建一个超级源点 s s s 和超级汇点 t t t，从 s s s 到黑点连边，容量为权值， 白点到 t t t 连边，容量为权值，黑点到白点连容量为 i n f inf inf 的边，求最小割，即是最小覆盖集。如图。

为什么最小割就是答案？
由于中间的边是 i n f inf inf，所以割不掉，只能割掉两边的边。由于割完后图不连通，所以两边至少选择一个点来割掉。因此最小割就是最小覆盖集的权值。
然后由于最大流 = 最小割，求最大流即可。
这算是最小割思想的应用。

代码如下

#include <bits/stdc++.h>
#define N 1000005
#define inf 2147483647
#define LL long long
using namespace std;
struct node{
	int a, b, c, n;
}d[N * 2];
int dep[N], h[N], cur[N], a[105][105], f[N], cnt = 1, tot, s, t;
LL ans, ans1;
void cr(int a, int b, int c){
	d[++cnt].a = a; d[cnt].b = b; d[cnt].c = c; d[cnt].n = h[a]; h[a] = cnt;
}
void lk(int a, int b, int c){
	cr(a, b, c);
	cr(b, a, 0);
}
int bfs(){
	int i, a, b, c;
	memset(dep, 0, sizeof(dep));
	for(i = 0; i <= tot; i++) cur[i] = h[i];
	queue<int> q;
	q.push(s);
	dep[s] = 1;
	while(!q.empty()){
		a = q.front();
		q.pop();
		for(i = h[a]; i; i = d[i].n){
			b = d[i].b;
			c = d[i].c;
			if(!dep[b] && c){
				dep[b] = dep[a] + 1;
				q.push(b);
			}
		}
	}
	return dep[t];
}
int dfs(int a, int flow){
	int i, b, c, w, used = 0;
	//printf("%d %d======\n", a, flow);
	if(a == t) return flow;
	for(i = cur[a]; i; i = d[i].n){
		cur[a] = i;
		b = d[i].b;
		c = d[i].c;
		if(dep[b] == dep[a] + 1 && c > 0){
			if(w = dfs(b, min(flow - used, c))){
				used += w;
				d[i].c -= w;
				d[i ^ 1].c += w;
			}
			if(used == flow) break;
		}
	}
	return used;
}
int main(){
	int i, j, n, m, k;
	scanf("%d%d", &n, &m);
	tot = n * m + 2;
	s = n * m + 1, t = n * m + 2;
	for(i = 1; i <= n; i++){
		for(j = 1; j <= m; j++){
			scanf("%d", &a[i][j]);
			ans1 += a[i][j];
			if((i + j) % 2){
				lk(s, (i - 1) * m + j, a[i][j]);
				if(j > 1) lk((i - 1) * m + j, (i - 1) * m + j - 1, inf);
				if(j < m) lk((i - 1) * m + j, (i - 1) * m + j + 1, inf);
				if(i > 1) lk((i - 1) * m + j, (i - 2) * m + j, inf);
				if(i < n) lk((i - 1) * m + j, i * m + j, inf);
			}
			else{
				lk((i - 1) * m + j, t, a[i][j]);
			}
		}
	}
	while(bfs()) ans += dfs(s, inf);
	printf("%lld", ans1 - ans);
	return 0;
}