bzoj2132: 圈地计划（无比强大的最小割）

2132: 圈地计划

题目：传送门

简要题意：

　　给出一个矩阵，一共n*m个点，并给出三个收益矩阵。A矩阵表示这个点建A的可取收益，B矩阵表示这个点建B的可取收益，C矩阵表示如果相邻（有且仅有一条公共边）的点和自己所建的建筑不一样，则可获得C[i][j]的收益，如果相邻的有k个点和自己不一样，则收益为k*C[i][j]。求最大收益。

题解：

　　 日常一模最小割%%%ORZ

　　 本蒟蒻其实也看出是最小割什么的，但是怎么割啊。。。

　　 可能有人会和我有一样的疑惑：

　　 按照正常的割法建图：st到x连A收益，x到ed连B收益，两两之间再连C收益

　　 连完之后就蒙B了...割出来的是什么鬼？？？

　　 这时我们会发现，这样子连的话负权边根本没有体现啊？？？

　　%题解啊啊啊：

　　 正解其实是需要进行黑白染色的（原因后面讲）

　　 染完色之后：st到黑点连A收益，黑点到ed连B收益；白点反之，然后相邻的不同颜色的格子相互连边（其实就是每个点还要连出去上下左右的点，因为染色了啊）

　　 这样之后用sum-最小割就OK。

　　 那染色是什么鬼：

　　 正确答案并不一定是相邻的点颜色都不一样，那么染色的目的就不是保证收益最大。

　　 但是染完色之后再跑最小割我们可以发现：

　　 如果某相邻两点异色的收益不如同色的收益，那么这条路径上关于相邻异色的收益肯定会被割掉

　　 如果异色收益更优，那割掉的肯定是一个A收益加一个B收益

　　 那么肯定是要最小割啊~

代码：

 #include<cstdio>
 #include<cstring>
 #include<cstdlib>
 #include<cmath>
 #include<algorithm>
 #define qread(x) x=read()
 using namespace std;
 inline int read()
 {
     int f=,x=;char ch;
     while(ch<'' || ch>''){if(ch=='-')f=-;ch=getchar();}
     while(ch>='' && ch<=''){x=x*+ch-'';ch=getchar();}
     return f*x;
 }
 struct node
 {
     int x,y,c,next,other;
 }a[];int len,last[];
 int n,m,st,ed,head,tail;
 void ins(int x,int y,int c)
 {
     int k1,k2;
     k1=++len;
     a[len].x=x;a[len].y=y;a[len].c=c;
     a[len].next=last[x];last[x]=len;

     k2=++len;
     a[len].x=y;a[len].y=x;a[len].c=;
     a[len].next=last[y];last[y]=len;

     a[k1].other=k2;
     a[k2].other=k1;
 }
 int list[],h[];
 bool bt_h()
 {
     memset(h,,sizeof(h));h[st]=;
     list[]=st;head=;tail=;
     while(head!=tail)
     {
         int x=list[head];
         for(int k=last[x];k;k=a[k].next)
         {
             int y=a[k].y;
             if(h[y]== && a[k].c>)
             {
                 h[y]=h[x]+;
                 list[tail++]=y;
             }
         }
         head++;
     }
     if(h[ed]>)return true;
     return false;
 }
 int find_flow(int x,int flow)
 {
     if(x==ed)return flow;
     int s=,t;
     for(int k=last[x];k;k=a[k].next)
     {
         int y=a[k].y;
         if(h[y]==h[x]+ && a[k].c> && s<flow)
         {
             s+=t=find_flow(y,min(a[k].c,flow-s));
             a[k].c-=t;a[a[k].other].c+=t;
         }
     }
     if(s==)h[x]=;
     return s;
 }
 int A[][],B[][],C[][];
 int f[][];//黑白染色 1为黑 2为白
 int d[][];
 int main()
 {
     qread(n);qread(m);
     len=;memset(last,,sizeof(last));
     st=n*m+;ed=st+;
     int s=;
     for(int i=;i<=n;i++)for(int j=;j<=m;j++)d[i][j]=(i-)*m+j;
     for(int i=;i<=n;i++)for(int j=;j<=m;j++)qread(A[i][j]);
     for(int i=;i<=n;i++)for(int j=;j<=m;j++)qread(B[i][j]);
     for(int i=;i<=n;i++)for(int j=;j<=m;j++)qread(C[i][j]);
     memset(f,,sizeof(f));
     for(int i=;i<=n;i++)
         for(int j=;j<=m;j++)
         {
             if(i== && j==)continue;
             if(j==)f[i][j]=f[i-][j]^;
             else f[i][j]=f[i][j-]^;
         }
     int sum=;
     for(int i=;i<=n;i++)
         for(int j=;j<=m;j++)
         {
             sum+=A[i][j]+B[i][j];
             if(f[i][j]==)
             {
                 ins(st,d[i][j],A[i][j]);
                 ins(d[i][j],ed,B[i][j]);
             }
             else
             {
                 ins(st,d[i][j],B[i][j]);
                 ins(d[i][j],ed,A[i][j]);
             }
         }
     for(int i=;i<=n;i++)
         for(int j=;j<=m;j++)
         {
             if(i->)ins(d[i][j],d[i-][j],C[i][j]+C[i-][j]),sum+=C[i][j];
             if(i+<=n)ins(d[i][j],d[i+][j],C[i][j]+C[i+][j]),sum+=C[i][j];
             if(j->)ins(d[i][j],d[i][j-],C[i][j]+C[i][j-]),sum+=C[i][j];
             if(j+<=m)ins(d[i][j],d[i][j+],C[i][j]+C[i][j+]),sum+=C[i][j];
         }
     int ans=;
     while(bt_h())ans+=find_flow(st,);
     printf("%d\n",sum-ans);
     return ;
 }