「网络流 24 题」方格取数【二分图点权最大独立集】woj2625

题意

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

问题分析

二分图点权最大独立集，转化为最小割模型，从而用最大流解决。

建模方法

首先把棋盘黑白染色，使相邻格子颜色不同，所有黑色格子看做二分图X集合中顶点，白色格子看做Y集合顶点，建立附加源S汇T。

1、从S向X集合中每个顶点连接一条容量为格子中数值的有向边。
2、从Y集合中每个顶点向T连接一条容量为格子中数值的有向边。
3、相邻黑白格子Xi,Yj之间从Xi向Yj连接一条容量为无穷大的有向边。

求出网络最大流，要求的结果就是所有格子中数值之和减去最大流量。

建模分析

这是一个二分图最大点权独立集问题，就是找出图中一些点，使得这些点之间没有边相连，这些点的权值之和最大。独立集与覆盖集是互补的，求最大点权独立集可以转化为求最小点权覆盖集（最小点权支配集）。最小点权覆盖集问题可以转化为最小割问题解决。

结论:最大点权独立集 = 所有点权 - 最小点权覆盖集 = 所有点权 - 最小割集 = 所有点权 - 网络最大流。

对于一个网络，除去冗余点（不存在一条ST路径经过的点），每个顶点都在一个从S到T的路径上。割的性质就是不存在从S到T的路径，简单割可以认为割边关联的非ST节点为割点，而在二分图网络流模型中每个点必关联到一个割点（否则一定还有增广路，当前割不成立），所以一个割集对应了一个覆盖集（支配集）。最小点权覆盖集就是最小简单割，求最小简单割的建模方法就是把XY集合之间的变容量设为无穷大，此时的最小割就是最小简单割了。

有关二分图最大点权独立集问题，更多讨论见《最小割模型在信息学竞赛中的应用》作者胡伯涛。

参考代码

#include<iostream>
#include<vector>
#include<queue>
#include<cstdio>
#include<cstring>
using namespace std;
#define ll long long
#define in rad()
inline int rad(){
	int x=0,f=1;char c=getchar();while(c>'9'||c<'0')c=getchar();
	if(c=='-')f=-1,c=getchar();while(c>='0'&&c<='9')x=x*10+c-48,c=getchar();
	return x*f;
}
const int maxn=1e4+10;
const int maxm=4e5+100;
const int inf=1e9;
struct Edge {
	int u,v,w,nxt;
} e[maxm] ;
int first[maxn]= {},cnt=1,S,T;
inline void add(int u,int v,int w) {
	e[++cnt].v=v;e[cnt].u=u;e[cnt].w=w;e[cnt].nxt=first[u];first[u]=cnt;
}
inline void ins(int u,int v,int w){
	add(u,v,w);add(v,u,0);
}
int n,m,g[40][40],mp[40][40]={};
namespace D{
	int dis[maxn],cur[maxn];
	int bfs(int s,int t){
		memset(dis,-1,sizeof(dis));
		queue<int>q;
		dis[s]=0;q.push(s);
		while(!q.empty()){
			int u=q.front();q.pop();
			for(int i=first[u];i;i=e[i].nxt){
				int v=e[i].v;
				if(dis[v]!=-1||e[i].w==0)continue;
				dis[v]=dis[u]+1;
				q.push(v);
				if(v==t)return 1;
			}
		}
		return 0;
	} 
	int dfs(int u,int t,int f){
		if(!f||u==t)return f;
		int w,used=0;
		for(int &i=cur[u];i;i=e[i].nxt){
			int v=e[i].v;
			if(dis[v]!=dis[u]+1||e[i].w==0)continue;
			w=dfs(v,t,min(f,e[i].w));
			used+=w;f-=w;
			e[i].w-=w;e[i^1].w+=w;
			if(f==0)break;
		}
		return used;
	}
	int dinic(int s,int t){
		int ret=0;
		while(bfs(s,t)){
			memcpy(cur,first,sizeof(first));
			ret+=dfs(s,t,inf);
		}
		return ret;
	}
}
int dx[]={0,0,1,-1};
int dy[]={1,-1,0,0};
inline int idx(int x,int y){
	return (x-1)*n+y ;
}
 
int main(){
  	m=in;n=in;S=0,T=m*n+1;
  	int sum=0;
	for(int i=1;i<=m;i++)
	for(int j=1;j<=n;j++){
		int x=in;
		sum+=x;
		if((i+j)&1){
			ins(S,idx(i,j),x);
			for(int k=0;k<4;k++){
				int tx=i+dx[k],ty=j+dy[k];
				if(tx<1 || ty<1 || tx>m || ty>n)continue;
				ins(idx(i,j),idx(tx,ty),inf);
			}
		}
		else
			ins(idx(i,j),T,x);
	}		
 
	cout<<sum-D::dinic(S,T);
	return 0;
}