hdu 1565 最大点权独立集

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

链接：点我

分析转自：点我

 

   二分图最小点覆盖和最大独立集都可以转化为最大匹配求解。在这个基础上，把每个点赋予一个非负的权值，这两个问题就转化为：二分图最小点权覆盖和二分图最大点权独立集。

 

    二分图最小点权覆盖

    从x或者y集合中选取一些点，使这些点覆盖所有的边，并且选出来的点的权值尽可能小。

建模：

    原二分图中的边(u,v)替换为容量为INF的有向边(u,v)，设立源点s和汇点t，将s和x集合中的点相连，容量为该点的权值；将y中的点同t相连，容量为该点的权值。在新图上求最大流，最大流量即为最小点权覆盖的权值和。

 

二分图最大点权独立集

    在二分图中找到权值和最大的点集，使得它们之间两两没有边。其实它是最小点权覆盖的对偶问题。答案=总权值-最小点覆盖集。具体证明参考胡波涛的论文。

 

先理理概念：

点覆盖集：无向图G的一个点集，使得该图中所有边都至少有一个端点在该集合内。

最小点权覆盖集：在带点权无向图G中，点权之和最小的覆盖集。

点独立集：无向图G的一个点集，使得任两个在该集合中的点在原图中都不相邻。
最大点权独立集：在带权无向图G中，点权之和最大的独立集。
定理：
1. 最小点权覆盖集=最小割=最大流
2. 最大点权独立集=总权-最小点权覆盖集

思路：

1. 先染色，取一个点染白色，和它相邻的点染黑色
2. 每个白点向它相邻的黑点连一条边，容量为 inf (无穷大)
3. 增加源点S，向每一个白色点连一条边，容量为白点的权
4. 增加汇点T，每个黑点向T连一条边，容量为黑点的权

  1 #include<iostream>

  2 #include<cstdio>

  3 #include<cstring>

  4 using namespace std;

  5 #define MAXN 5555

  6 #define MAXM 222222

  7 #define inf 1<<30

  8 

  9 struct Edge{

 10     int v,cap,next;

 11 }edge[MAXM];

 12 

 13 int head[MAXN];

 14 int pre[MAXN];

 15 int cur[MAXN];

 16 int level[MAXN];

 17 int gap[MAXN];

 18 int NE,NV,n,vs,vt;

 19 int dir[4][2]={{0,-1},{0,1},{-1,0},{1,0}};

 20 int map[55][55];

 21 bool mark[55][55];

 22 

 23 void Insert(int u,int v,int cap,int cc=0){

 24     edge[NE].v=v;edge[NE].cap=cap;

 25     edge[NE].next=head[u];head[u]=NE++;

 26 

 27     edge[NE].v=u;edge[NE].cap=cc;

 28     edge[NE].next=head[v];head[v]=NE++;

 29 }

 30 

 31 int SAP(int vs,int vt){

 32     memset(pre,-1,sizeof(pre));

 33     memset(level,0,sizeof(level));

 34     memset(gap,0,sizeof(gap));

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

 36     int u=pre[vs]=vs,maxflow=0,aug=-1;

 37     gap[0]=NV;

 38     while(level[vs]<NV){

 39 loop:

 40         for(int &i=cur[u];i!=-1;i=edge[i].next){

 41             int v=edge[i].v;

 42             if(edge[i].cap&&level[u]==level[v]+1){

 43                 aug==-1?aug=edge[i].cap:aug=min(aug,edge[i].cap);

 44                 pre[v]=u;

 45                 u=v;

 46                 if(v==vt){

 47                     maxflow+=aug;

 48                     for(u=pre[u];v!=vs;v=u,u=pre[u]){

 49                         edge[cur[u]].cap-=aug;

 50                         edge[cur[u]^1].cap+=aug;

 51                     }

 52                     aug=-1;

 53                 }

 54                 goto loop;

 55             }

 56         }

 57         int minlevel=NV;

 58         for(int i=head[u];i!=-1;i=edge[i].next){

 59             int v=edge[i].v;

 60             if(edge[i].cap&&minlevel>level[v]){

 61                 cur[u]=i;

 62                 minlevel=level[v];

 63             }

 64         }

 65         gap[level[u]]--;

 66         if(gap[level[u]]==0)break;

 67         level[u]=minlevel+1;

 68         gap[level[u]]++;

 69         u=pre[u];

 70     }

 71     return maxflow;

 72 }

 73 

 74 int main(){

 75     while(~scanf("%d",&n)){

 76         vs=0,vt=n*n+1,NE=0,NV=n*n+2;

 77         int sum=0;

 78         memset(head,-1,sizeof(head));

 79         memset(mark,false,sizeof(mark));

 80         for(int i=1;i<=n;i++){

 81             for(int j=1;j<=n;j++){

 82                 scanf("%d",&map[i][j]);

 83                 sum+=map[i][j];

 84             }

 85         }

 86         for(int i=1;i<=n;i++){

 87             for(int j=1;j<=n;j++){

 88                 if(!mark[i][j]){

 89                     Insert(vs,(i-1)*n+j,map[i][j]);

 90                     for(int k=0;k<4;k++){

 91                         int x=i+dir[k][0];

 92                         int y=j+dir[k][1];

 93                         if(x>=1&&x<=n&&y>=1&&y<=n){

 94                             Insert((i-1)*n+j,(x-1)*n+y,inf);

 95                             //建图的时候要小心，每个点只能连一次

 96                             if(!mark[x][y])Insert((x-1)*n+y,vt,map[x][y]);

 97                             mark[x][y]=true;

 98                         }

 99                     }

100                 }

101             }

102         }

103         printf("%d\n",sum-SAP(vs,vt));

104     }

105     return 0;

106 }

2015/5/31