方格取数(2) （最大独立集+最大流+网络流）

给你一个m*n的格子的棋盘，每个格子里面有一个非负数。 
从中取出若干个数，使得任意的两个数所在的格子没有公共边，就是说所取数所在的2个格子不能相邻，并且取出的数的和最大。

Input

包括多个测试实例，每个测试实例包括2整数m,n和m*n个非负数(m<=50,n<=50)

Output

对于每个测试实例，输出可能取得的最大的和

Sample Input

3 3
75 15 21 
75 15 28 
34 70 5

Sample Output

188

题意：中文。。。

思路：

此题目就是刘汝佳书中说的常见的建模与模型变换中的二分图带权最大独立集。给出一个二分图，每个节点上有一个正权值。要求选出一些点，使得这些点之间没有边相连，且权值和最大。解决办法是：

在二分图的基础上添加源点S和汇点t，然后从s向所有x集合中的点连一条边，所有Y集合中的点向T连一条边，流量均为该点的权值。x结点和Y结点之间的边容量均为无穷大。这样，对于该图中的任意一个割，将割中的边对应的结点删掉就是一个符号要求的解。权和为所有权和减去割的容量。因此，只需要求出最小割，就能求出最大权和。

此题目根据横纵坐标之和将图中的点分为x和Y两个集合，如果(i+j)&1说明为奇数归为Y集合，建边y到t流量为该点权值，然后其他的为x集合，建边s到x流量仍为权值，然后x和Y集合之间的点建边INF，跑一边最大流，记录下矩阵的总和，总和减去得到的最大流集合权值和。

代码：

#include<map>
#include<vector>
#include<queue>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<cmath>
#define maxn 4000
#define PI acos(-1.0)
#define INF 1e9  
using namespace std;
typedef long long ll;

struct Edge{
	int from,to,cap,flow;
	Edge(){}
	Edge(int f,int t,int c,int fl):from(f),to(t),cap(c),flow(fl){}
}; 

struct Dinic{
	int n,m,s,t;
	vector<Edge>edges;
	vector<int>G[maxn];
	bool vis[maxn];
	int d[maxn];
	int cur[maxn];
	
	void init(int s,int t){
		this->s=s;
		this->t=t;
		for(int i=0;i<maxn;i++){
			G[i].clear();
		}
		edges.clear();
	}
	
	void AddEdge(int from,int to,int cap){
		edges.push_back((Edge){from,to,cap,0});
		edges.push_back((Edge){to,from,0,0}) ;
		m=edges.size();
		G[from].push_back(m-2);
		G[to].push_back(m-1);
	}
	
	bool BFS(){
		memset(vis,0,sizeof(vis));
		queue<int>Q;
		Q.push(s);
		d[s] = 0;
		vis[s]=1;
		while(!Q.empty()){
			int x=Q.front();
			Q.pop();
			for(int i=0;i<G[x].size();i++){
				Edge &e=edges[G[x][i]];
				if(!vis[e.to]&&e.cap>e.flow){
					vis[e.to]=1;
					d[e.to]=d[x]+1;
					Q.push(e.to);
				}
			}
		}
		return vis[t]	;
	}
	
	int DFS(int x,int a) {
		if(x==t||a==0) return a;
		int flow=0,f;
		for(int& i=cur[x];i<G[x].size();i++){
			Edge& e =edges[G[x][i]];
			
			if(d[x]+1==d[e.to]&&(f=DFS(e.to,min(a,e.cap-e.flow)))>0){
				e.flow+=f;
				edges[G[x][i]^1].flow-=f;
				flow+=f;
				a-=f;
				if(a==0) break;
			}
		}
		return flow;
	}
	
	int Maxflow(){
		int flow=0;
		while(BFS()){
			memset(cur,0,sizeof(cur));
			flow+=DFS(s,INF);
		}
		return flow;
	}
}DC; 

int mp[maxn][maxn];

int main()
{
	int n,m;
	while(~scanf("%d%d",&n,&m)){
		int src=0,dst=n*m+1;
		
		DC.init(src,dst) ;
		
		int sum=0;
		for(int i=1;i<=n;i++)
			for(int j=1;j<=m;j++){
				scanf("%d",&mp[i][j]);
				sum+=mp[i][j];
			}
		
		for(int i=1;i<=n;i++){
			for(int j=1;j<=m;j++){
				if((i+j)&1) DC.AddEdge((i-1)*m+j,dst,mp[i][j]);
				else{
					DC.AddEdge(src,(i-1)*m+j,mp[i][j]);
					if(j>1) DC.AddEdge((i-1)*m+j,(i-1)*m+j-1,INF);
					if(j<m) DC.AddEdge((i-1)*m+j,(i-1)*m+j+1,INF);
					if(i>1) DC.AddEdge((i-1)*m+j,(i-2)*m+j,INF);
					if(i<n) DC.AddEdge((i-1)*m+j,i*m+j,INF);
				}
			}
		}
		printf("%d\n",sum-DC.Maxflow());		
	} 
    return 0;
}