HDU1565 方格取数(1)

Problem Description

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

 

Input

包括多个测试实例，每个测试实例包括一个整数n 和n*n个非负数(n<=20)

 

Output

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

 

Sample Input

3
75 15 21
75 15 28
34 70 5

Sample Output

188

Author

ailyanlu

Source

Happy 2007

 

 

正解：网络流

解题报告：

　　网络流24题第9题。同样是可以转换为最大点权和独立集，求最小割跑最大流。自己的题解：

　　模型：建图+最小割

　　总结：

　　和前面做的几道题很类似，都是求最大独立集。事实上都可以转换成二分图，然后按照最小割模型来做。

　　考虑这道题说不能选取有相邻边的格子中的数，相当于是如果选取了当前格子，那么周围相邻的四个格子都不能再选。这个模型显然就是一个二分图，所以首先我们可以先把全图进行二分图染色，对于一个点坐标为（i，j），如果（i+j）%2==0，那么染成白色；否则，染成黑色。然后新建源点S，向所有白色点连一条容量为该点点权的有向边；新建汇点T，所有黑色点连一条容量为该点点权的有向边。对于所有白色点，向四周的所有黑色点都连一条容量为无穷的有向边。如此以来我们构出了一张图（跟前几道题一样的说）。

　　显然我们希望得到选取的尽可能多的格子，由于都是正数所以肯定能选尽量选。但是如果选了一个格子，就意味着四周的全都不能再选了，也就是说如果我们把ans初值记为所有格子权值之和，那么我们每次因为选择了一个格子就会失去周围四个的权值，需要从ans中减掉。这跟什么很像呢？最大半连通子图！是的，一样的做法，用总的和减去最小割就可以得到我们期望的最大值。

　　

 

 //It is made by jump~
 #include <iostream>
 #include <cstdlib>
 #include <cstring>
 #include <cstdio>
 #include <cmath>
 #include <algorithm>
 #include <ctime>
 #include <vector>
 #include <queue>
 #include <map>
 #include <set>
 #ifdef WIN32
 #define OT "%I64d"
 #else
 #define OT "%lld"
 #endif
 using namespace std;
 typedef long long LL;
 const int MAXN = ;
 const int MAXM = ;
 const int inf = (<<);
 int n,sum,S,T,ecnt,ans;
 int a[MAXN][MAXN],deep[MAXN*MAXN];
 int first[MAXN*MAXN];
 queue<int>Q;
 struct edge{
     int next,to,f;
 }e[MAXM];

 inline int getint()
 {
        int w=,q=;
        char c=getchar();
        while((c<'' || c>'') && c!='-') c=getchar();
        if (c=='-')  q=, c=getchar();
        while (c>='' && c<='') w=w*+c-'', c=getchar();
        return q ? -w : w;
 }

 inline void link(int x,int y,int z){
     e[++ecnt].next=first[x]; first[x]=ecnt; e[ecnt].to=y; e[ecnt].f=z;
     e[++ecnt].next=first[y]; first[y]=ecnt; e[ecnt].to=x; e[ecnt].f=;
 }

 inline bool bfs(){
     while(!Q.empty()) Q.pop();
     for(int i=;i<=T;i++) deep[i]=;
     Q.push(S); deep[S]=;
     while(!Q.empty()) {
     int u=Q.front(); Q.pop();
     for(int i=first[u];i;i=e[i].next) {
         int v=e[i].to;
         if(e[i].f && !deep[v]) deep[v]=deep[u]+,Q.push(v);
     }
     }
     if(deep[T]!=) return true;
     return false;
 }

 inline int Dinic(int x,int remain){
     if(remain== || x==T) return remain;
     int f,flow=;
     for(int i=first[x];i;i=e[i].next) {
     int v=e[i].to;
     if(e[i].f && deep[v]==deep[x]+){
         f=Dinic(v,min(remain,e[i].f));
         if(f){
         flow+=f; e[i].f-=f; e[i^].f+=f;
         remain-=f; if(remain==) return flow;
         } else deep[v]=-;
     }
     }
     return flow;
 }

 inline void work(){
     while(scanf("%d",&n)!=EOF) {
     sum=;
     for(int i=;i<=n;i++) for(int j=;j<=n;j++)   a[i][j]=getint(),sum+=a[i][j];
     S=n*n+;T=S+; ecnt=; memset(first,,sizeof(first));
     for(int i=;i<=n;i++) for(int j=;j<=n;j++) if((i+j)%==) link(S,(i-)*n+j,a[i][j]); else link((i-)*n+j,T,a[i][j]);//黑白染色
     for(int i=;i<=n;i++)
         for(int j=;j<=n;j++){
         if((i+j)%) continue;
         if(i!=) link((i-)*n+j,(i-)*n+j,inf);
         if(j!=) link((i-)*n+j,(i-)*n+j-,inf);
         if(j!=n) link((i-)*n+j,(i-)*n+j+,inf);
         if(i!=n) link((i-)*n+j,i*n+j,inf);
         }
     ans=;
     while(bfs()) ans+=Dinic(S,inf);
     printf("%d\n",sum-ans);
     }
 }

 int main()
 {
   work();
   return ;
 }