【BZOJ1475】方格取数 [最小割]

方格取数

Time Limit: 5 Sec  Memory Limit: 64 MB
[Submit][Status][Discuss]

Description

　　在一个n*n的方格里，每个格子里都有一个正整数。从中取出若干数，使得任意两个取出的数所在格子没有公共边，且取出的数的总和尽量大。

Input

　　第一行一个数n；接下来n行每行n个数描述一个方阵

Output

　　仅一个数，即最大和

Sample Input

　　2
　　1 2
　　3 5

Sample Output

　　6

HINT

　　n<=30

Main idea

　　给定一个矩阵，取了一个点就不能取上下左右的点了，求能取出的最大价值。

Solution

　　求的显然是最大权独立集，最大权独立集=总权-最小权覆盖集，对于最小权覆盖集我们用最小割来解。

　　由于取了一个点，不能取上下左右的点，即i+-1 or j+-1，那么显然是一个二分图，根据奇偶分类。

　　然后就是一个最小割的模型，我们左边的点向上下左右的点连边，容量为INF(必然不是割)，然后跑最大流即可。

Code

 #include<iostream>
 #include<string>
 #include<algorithm>
 #include<cstdio>
 #include<cstring>
 #include<cstdlib>
 #include<cmath>
 #include<map>
 using namespace std;  

 const int ONE=;
 const int TWO=;
 const int INF=;

 int n,m;
 int tot=;
 int res,tou,wei,S,T;
 int Dep[ONE],q[TWO],ans;
 int a[ONE][ONE],PD[ONE][ONE],BI[ONE][ONE];
 int next[TWO],first[TWO],go[TWO],w[TWO];
 int E[ONE];

 int get()
 {
         int res=,Q=;char c;
         while( (c=getchar())< || c> )
         if(c=='-')Q=-;
         res=c-;
         while( (c=getchar())>= && c<= )
         res=res*+c-;
         return res*Q;
 }         

 int Add(int u,int v,int z)
 {
         next[++tot]=first[u];   first[u]=tot;   go[tot]=v;  w[tot]=z;
         next[++tot]=first[v];   first[v]=tot;   go[tot]=u;  w[tot]=;
 }

 int Bfs()
 {
         memset(Dep,,sizeof(Dep));
         q[]=;
         tou=;  wei=;  Dep[]=;
         for(int u=;u<=n*n;u++) E[u]=first[u];
         while(tou<wei)
         {
             int u=q[++tou];
             for(int e=first[u];e;e=next[e])
             {
                 int v=go[e];
                 if(Dep[v] || !w[e])continue;
                 Dep[v]=Dep[u]+;
                 q[++wei]=v;
             }
         }
         return (Dep[T]>);
 }

 int Dfs(int u,int Limit)
 {
         if(u==T || !Limit) return Limit;
         int flow=,f;
         for(int &e=E[u];e;e=next[e])
         {
             int v=go[e];
             if(Dep[v]!=Dep[u]+ || !w[e]) continue;
             f=Dfs(v,min(Limit,w[e]));
             w[e]-=f;
             w[e^]+=f;
             Limit-=f;
             flow+=f;
             if(!Limit)break;
         }
         return flow;
 }

 void Build(int i,int j)
 {
         if(BI[i-][j])  Add(BI[i][j],BI[i-][j],INF);
         if(BI[i][j-])  Add(BI[i][j],BI[i][j-],INF);
         if(BI[i+][j])  Add(BI[i][j],BI[i+][j],INF);
         if(BI[i][j+])  Add(BI[i][j],BI[i][j+],INF);
 }

 int main()
 {
         n=get();
         for(int i=;i<=n;i++)
         for(int j=;j<=n;j++)
         {
             a[i][j]=get();
             ans+=a[i][j];
             if( i%!=j% ) PD[i][j]=;
             BI[i][j]=++tot;
         }

         S=;    T=n*n+;    tot=;
         for(int i=;i<=n;i++)
         for(int j=;j<=n;j++)
         {
             if(PD[i][j]) Add(S,BI[i][j],a[i][j]);
             else Add(BI[i][j],T,a[i][j]);
             if(PD[i][j])    Build(i,j);
         }

         while(Bfs())
         res+=Dfs(,INF);

         printf("%d",ans-res);
 }