HDU-1565,1569 最大点权独立集(网络流)

题目连接

HDU 1565和1569同属一个问题：最大点权独立集。

这是一个二分图最大点权独立集，就是找出图中一些点，使得这些点之间没有变相连，这些点的权值之和最大。独立集与覆盖集是互补的，求最大点独立集可以转化为

最小点权覆盖集(最小点权支配集)，最小点权覆盖集问题可以转化为最小割问题。

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

再就是建图了。

分奇偶。

把（i+j)的数奇数的点与源点连接，容量为改点的权值。

把(i+j)为偶数的点与汇点连接。。。。

相邻的点之间的容量设为无穷大。

HDU 1565 (0ms)

#include<cstdio>
#include<algorithm>
#include<cstring>
#define INF 1<<28
using namespace std;
const int M=3000;
struct node{
	int v,c,next;
}edge[M*10];

int pre[M],gap[M],level[M],head[M],cur[M];
int cnt;

inline void inint()
{
	memset(pre,-1,sizeof(pre));
	memset(gap,0,sizeof(gap));
	memset(level,0,sizeof(level));
	memset(head,-1,sizeof(head));
}

inline void add(int u,int v,int c)
{
	edge[cnt].v=v;
	edge[cnt].c=c;
	edge[cnt].next=head[u];
	head[u]=cnt++;
	
	edge[cnt].v=u;
	edge[cnt].c=0;
	edge[cnt].next=head[v];
	head[v]=cnt++;
}

int sap(int S,int T)
{
	int u=pre[S]=S,ans=0,tmp=-1,v;	
	for(int i=0;i<=T;i++) cur[i]=head[i];	
	gap[0]=T+1;
	while(level[S]<=T){
	loop:
		for(int &i=cur[u];i!=-1;i=edge[i].next){
			v=edge[i].v;
			if(edge[i].c&&level[v]+1==level[u]){
				tmp==-1?tmp=edge[i].c:tmp=min(edge[i].c,tmp);
				pre[v]=u;
				u=v;
				if(v==T){
					ans+=tmp;
					for(u=pre[u];v!=S;v=u,u=pre[u]){
						edge[cur[u]].c-=tmp;
						edge[cur[u]^1].c+=tmp;
					}
					tmp=-1;
				}
				goto loop;
			}
		}
		int ml=T+1;
		for(int i=head[u];i!=-1;i=edge[i].next){
			v=edge[i].v;
			if(edge[i].c&&ml>level[v]){
				cur[u]=i;
				ml=level[v];
			}
		}
		if(--gap[level[u]]==0) break;
		gap[level[u]=ml+1]++;
		u=pre[u];
	}
	return ans;
}

int main()
{
	int S,T,n,sum,c;
	while(~scanf("%d",&n)){
		inint();
		S=0,T=n*n+1;
		sum=cnt=0;
		for(int i=1;i<=n;i++){
			for(int j=1;j<=n;j++){
				scanf("%d",&c);
				sum+=c;		
			    if((i+j)&1){
			     add(S,(i-1)*n+j,c);
			     if(i>1) add((i-1)*n+j,(i-2)*n+j,INF);
			     if(j>1) add((i-1)*n+j,(i-1)*n+j-1,INF);
			     if(i<n) add((i-1)*n+j,i*n+j,INF);
			     if(j<n) add((i-1)*n+j,(i-1)*n+j+1,INF);
			   }
			   else add((i-1)*n+j,T,c);
		   }
		}
		printf("%d\n",sum-sap(S,T));
	}
	return 0;
}

HDU 1569(0ms)

#include<cstdio>
#include<cstring>
#include<algorithm>
#define INF 1<<28
using namespace std;
const int M=3000;
int head[M],pre[M],cur[M],level[M];
int map[M];
int s,t,cnt;

struct node{
	int v,cap,next;
}edge[M*10];

inline void Add(int u,int v,int w) //加个内置函数，HDU测试是0ms. 
{
	edge[cnt].v=v;
	edge[cnt].cap=w;
	edge[cnt].next=head[u];
	head[u]=cnt++;
	
	edge[cnt].v=u;
	edge[cnt].cap=0;
	edge[cnt].next=head[v];
	head[v]=cnt++;
}

int SAP(int s,int t)
{
	memset(pre,-1,sizeof(pre));
	memset(level,0,sizeof(level));
	memset(map,0,sizeof(map));
	for(int i=0;i<=t;i++) cur[i]=head[i];
	int u=pre[s]=s,ans=0,tmp=-1;
	map[0]=t+1;
	while(level[s]<=t){
		loop:
			for(int &i=cur[u];i!=-1;i=edge[i].next){
				int v=edge[i].v;
				if(edge[i].cap&&level[u]==level[v]+1){
					tmp==-1?tmp=edge[i].cap:tmp=min(tmp,edge[i].cap);
					pre[v]=u;
					u=v;
					if(v==t){
						ans+=tmp;
						for(u=pre[u];v!=s;v=u,u=pre[u]){
							edge[cur[u]].cap-=tmp;
							edge[cur[u]^1].cap+=tmp;
						}
						tmp=-1;
					}
					goto loop;
				}
			}
			int minlevel=t+1;
			for(int i=head[u];i!=-1;i=edge[i].next){
				int v=edge[i].v;
				if(edge[i].cap&&minlevel>level[v]){
					cur[u]=i;
					minlevel=level[v];
				}
			}
			if(--map[level[u]]==0) break;	
			map[level[u]=minlevel+1]++;
			u=pre[u];
	}
	return ans;
}

int main()
{
	int n,m,sum,x,y,c;
	while(~scanf("%d %d",&n,&m)){
		s=0,t=n*m+1;
		cnt=0;
		sum=0;
		memset(head,-1,sizeof(head));
		for(int i=1;i<=n;i++){
			for(int j=1;j<=m;j++){
				scanf("%d",&c);
				sum+=c;
				if((i+j)&1){   //奇偶随便选一个都行。 
					Add(s,(i-1)*m+j,c);
					if(i>1) Add((i-1)*m+j,(i-2)*m+j,INF);  //以下是四个方向都需添加。 
					if(j>1) Add((i-1)*m+j,(i-1)*m+j-1,INF);
					if(i<n) Add((i-1)*m+j,i*m+j,INF);
					if(j<m) Add((i-1)*m+j,(i-1)*m+j+1,INF);
				}
				else Add((i-1)*m+j,t,c);
			}
		}
	 printf("%d\n",sum-SAP(s,t));
   }
   return 0;
}