hdu_1565&1569

1565和1569除了数据范围和输入不一样之外其余的都一样

这题是最典型的最大点权独立集。
实际上，我们要先算最小点权覆盖集，然后用总的点权和-最小点权覆盖集，得出答案。
 
我们要把原图改成二分图。
进行黑白染色，比如一个3*3的矩阵
1 2 3
4 5 6
7 8 9
那么点1，3，5，7，9为一个集合(n)
点2，4，6，8为一个集合(m)
源点连向n集合，m集合连向汇点，容量都是点权值
n,m之间如果直接相邻，那么就连一条容量为inf的边
比如，1需要建边1->2,1->4
5需要建边5->2,5->4,5->6,5->8
根据定理，求出最小点权覆盖集（即最小割）
用总点权减去最小割，就是要求的最大点权独立集
 
这样的没有证明，只有结论的解题报告我不太喜欢。
我说说我对最小割=最小点权覆盖集的理解。
我们要求的是：选出一些点来，使他们覆盖所有的点，并且使点权和最小。
两个相邻的点，必然至少有一个点要被选中。
因为两条点如果相邻，连接他们的边是inf,在求最小割的时候必然不会选inf的边。
只能选取与源点相连，或者与汇点相连的边。
如果选取一条与源点（汇点）相邻的边，就等于选取了集合n（m）中的点。
我们可以把割边当作割点，跟二分匹配中类似————去掉某个点。
这样，可以看出，这个图的一个割其实就是一种点权覆盖集的一个方法。
最小点权覆盖集，当然就是最小割了。
 
至于最小点权覆盖集 = 点权和 - 最大点权独立集，我就不知道怎么证明了，感觉就是要用“显然”这样的字眼了。
 
具体证明参看《最小割模型在信息学竞赛中的应用》

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#define DIR		4
#define MAXN	2502
#define MAXM	100000
#define INF		0x7fffffff
using namespace std;

struct Edge {
	int v, val, next;
}edge[MAXM];

int dir[][2] = { {1, 0}, {-1, 0}, {0, 1}, {0, -1} };
int e_cnt, head[MAXN], pre[MAXN], dis[MAXN], gap[MAXN], cur[MAXN];

void insert_arc(int u, int v, int w)
{
	edge[e_cnt].v = v;	edge[e_cnt].val = w;
	edge[e_cnt].next = head[u];	head[u] = e_cnt ++;
	swap(u, v);
	edge[e_cnt].v = v;	edge[e_cnt].val = 0;
	edge[e_cnt].next = head[u];	head[u] = e_cnt ++;
}

void bfs(int des)
{
	int u, v;
	queue<int> q;
	memset(gap, 0, sizeof(gap));
	memset(dis, -1, sizeof(dis));
	gap[0] = 1;	dis[des] = 0;
	q.push(des);
	while( !q.empty() )
	{
		u = q.front(); q.pop();
		for(int i = head[u]; i != -1; i = edge[i].next)
		{
			v = edge[i].v;
			if( edge[i].val || dis[v] != -1 )	continue;
			dis[v] = dis[u]+1; gap[dis[v]] ++; q.push(v);
		}
	}
}

int i_sap(int src, int des, int VN)
{
	int u(src), v, min_dis, max_flow(0), path_flow(INF);
	bfs(des); pre[u] = u;

	for(int i = 0; i <= VN; i ++) 
		cur[i] = head[i];

	while( dis[src] < VN )
	{
loop:
		for(int &i = cur[u]; i != -1; i = edge[i].next)
		{
			v = edge[i].v;
			if( !edge[i].val || dis[u] != dis[v]+1 )	continue;
			path_flow = min(path_flow, edge[i].val);
			pre[v] = u; u = v;
			if( v == des )
			{
				for(u = pre[u]; v != src; v = u, u = pre[u])
				{
					edge[cur[u]].val -= path_flow; 
					edge[cur[u]^1].val += path_flow;
				}
				max_flow += path_flow; path_flow = INF;
			}
			goto loop;
		}
		min_dis = VN;
		for(int i = head[u]; i != -1; i = edge[i].next)
		{
			v = edge[i].v;
			if( edge[i].val && min_dis > dis[v] )
			{
				min_dis = dis[v];
				cur[u] = i;
			}
		}
		gap[dis[u]] --;
		if( !gap[dis[u]] )	break;
		dis[u] = min_dis+1;
		gap[dis[u]] ++;	u = pre[u];
	}
	return max_flow;
}

int main(int argc, char const *argv[])
{
	//freopen("test.in", "r", stdin);
	int col, row, src, des, sum_val, v, index, tx, ty;
	while( ~scanf("%d %d", &row, &col) )
	{
		src = row*col+1;	des = src+1;
		e_cnt = sum_val = 0;
		memset(head, -1, sizeof(head));
		for(int i = 0; i < row; i ++)
		{
			for(int j = 0; j < col; j ++)
			{
				scanf("%d", &v);	sum_val += v;	index = i*col+j;
				if( (i+j)&1 )
				{
					insert_arc(src, index, v);
					for(int d = 0; d < DIR; d ++)
					{
						tx = i+dir[d][0]; ty = j+dir[d][1];
						if( tx < 0 || ty < 0 || tx >= row || ty >= col )
							continue;
						insert_arc(index, tx*col+ty, v);
					}
				}
				else
					insert_arc(index, des, v);
			}
		}
		printf("%d\n", sum_val - i_sap(src, des, des+1));
	}
	return 0;
}