BZOJ2132: 圈地计划

题目链接

【题目】

• Description

  最近房地产商GDOI(Group of Dumbbells Or Idiots)从NOI(Nuts Old Idiots)手中得到了一块开发土地。据了解，这块土地是一块矩形的区域，可以纵横划分为N×M块小区域。GDOI要求将这些区域分为商业区和工业区来开发。根据不同的地形环境，每块小区域建造商业区和工业区能取得不同的经济价值。更具体点，对于第i行第j列的区域，建造商业区将得到Aij收益，建造工业区将得到Bij收益。另外不同的区域连在一起可以得到额外的收益，即如果区域(I,j)相邻（相邻是指两个格子有公共边）有K块（显然K不超过4）类型不同于(I,j)的区域，则这块区域能增加k×Cij收益。经过Tiger.S教授的勘察，收益矩阵A,B,C都已经知道了。你能帮GDOI求出一个收益最大的方案么？

• Input

  输入第一行为两个整数，分别为正整数N和M，分别表示区域的行数和列数；第2到N+1列，每行M个整数，表示商业区收益矩阵A；第N+2到2N+1列，每行M个整数，表示工业区收益矩阵B；第2N+2到3N+1行，每行M个整数，表示相邻额外收益矩阵C。第一行，两个整数，分别是n和m（1≤n，m≤100）；

  任何数字不超过1000”的限制

• Output

  输出只有一行，包含一个整数，为最大收益值

• Sample Input

  3 3

  1 2 3

  4 5 6

  7 8 9

  9 8 7

  6 5 4

  3 2 1

  1 1 1

  1 3 1

  1 1 1

• Sample Output

  81

• 【数据规模】

  对于100%的数据有N,M≤100

【分析】

• 一块地非商业区及工业区。
• 最大收益=所有可能收益-无法达到收益。
• 通过以上两点，即可想到最小割。

【建图】

• 正常建立最小割，两块之间收益为正，代价为负，所以边权要为负，显然错误。那么若将矩阵黑白染色后，黑格（白格）ST反向，即割掉两块之间的边就是同一用途，代价为正。如此，便可完美解决。
  ①：S向黑点i连边，容量为A[i]，黑点i向T连边，容量为B[i]；
  ②：S向白点i连边，容量为B[i]，白点i向T连边，容量为A[i]；
  ③：每个点i向四个相邻点j连边，容量为C[i]+C[j]。

【代码】

#include <cstdio>
#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <stack>
#define N 10005
#define M 120005
#define INF 1000000001
using namespace std;
typedef long long ll;
typedef pair<ll,ll> pa;

int read()
{
    int x=0,f=1;char ch=getchar();
    while(!isdigit(ch)){if(ch=='-') f=-1;ch=getchar();}
    while(isdigit(ch)){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}

int n,m,cnt=1,S,T,ans;
int b[M],p[N],nextedge[M],w[M],cur[N];
int Level[N];
int A[105][105],B[105][105],C[105][105];
int dx[]={0,0,1,-1};
int dy[]={1,-1,0,0};

void Add(int x,int y,int z)
{
    cnt++;
    b[cnt]=y;
    nextedge[cnt]=p[x];
    p[x]=cnt;
    w[cnt]=z;
}

void Anode(int x,int y,int z){
    Add(x,y,z);Add(y,x,0);
}

void Input_Init()
{
    n=read(),m=read();T=n*m+1;
    for(int i=1;i<=n;i++)
    for(int j=1;j<=m;j++) A[i][j]=read(),ans+=A[i][j];
    for(int i=1;i<=n;i++)
    for(int j=1;j<=m;j++) B[i][j]=read(),ans+=B[i][j];
    for(int i=1;i<=n;i++)
    for(int j=1;j<=m;j++) C[i][j]=read();
    for(int i=1;i<=n;i++)
    for(int j=1;j<=m;j++)
    {
        static int x,y;
        x=(i-1)*m+j;
        if((i+j)&1) Anode(0,x,A[i][j]),Anode(x,T,B[i][j]);
        else Anode(0,x,B[i][j]),Anode(x,T,A[i][j]);
        for(int k=0;k<4;k++)
        {
            static int xx,yy;
            xx=i+dx[k],yy=j+dy[k];
            if(xx<1||yy<1||xx>n||yy>m) continue;
            y=(xx-1)*m+yy;
            Anode(x,y,C[i][j]+C[xx][yy]);ans+=C[i][j]; 
        }
    }
}

bool Bfs()
{
    queue<int>q;
    q.push(S);
    for(int i=0;i<=T;i++) Level[i]=0;
    Level[S]=1;
    while(!q.empty())
    {
        int k=q.front();q.pop();
        for(int i=p[k];i;i=nextedge[i])
        {
            int v=b[i],f=w[i];
            if(!Level[v]&&f)
            {
                Level[v]=Level[k]+1;
                q.push(v);
            }
        }
    }
    return Level[T];
}

int Dfs(int x,int maxf)
{
    if(x==T||!maxf) return maxf;
    int rtn=0;
    for(int i=cur[x];i&&maxf>rtn;i=nextedge[i])
    {
        int v=b[i],f=w[i];
        if(Level[v]==Level[x]+1&&f)
        {
            f=Dfs(v,min(maxf-rtn,f));
            w[i]-=f;w[i^1]+=f;
            if(w[i]>0) cur[x]=i;
            rtn+=f;
        }
    }
    if(!rtn) Level[x]=0;
    return rtn;
}

void Dinic()
{
    while(Bfs())
    {
        for(int i=0;i<=T;i++) cur[i]=p[i];
        ans-=Dfs(S,INF);
    }   
    printf("%d\n",ans);
}

int main()
{
    Input_Init();
    Dinic();
    return 0;
}