[bzoj3894]文理分科

文理分科是一件很纠结的事情！（虽然看到这个题目的人肯定都没有纠结过）

 小P所在的班级要进行文理分科。他的班级可以用一个n*m的矩阵进行

描述，每个格子代表一个同学的座位。每位同学必须从文科和理科中选择

一科。同学们在选择科目的时候会获得一个满意值。满意值按如下的方式

得到：

1．如果第i行第j列的同学选择了文科，则他将获得art[i][j]的满意值，如

  果选择理科，将得到science[i][j]的满意值。

2．如果第i行第j列的同学选择了文科，并且他相邻（两个格子相邻当且

  仅当它们拥有一条相同的边）的同学全部选择了文科，则他会更开

  心，所以会增加same_art[i][j]的满意值。

3．如果第i行第j列的同学选择了理科，并且他相邻的同学全部选择了理

  科，则增加same_science[i]j[]的满意值。

  小P想知道，大家应该如何选择，才能使所有人的满意值之和最大。请

告诉他这个最大值。

Input

第一行为两个正整数：n，m

接下来n行m个整数，表示art[i][j]；

接下来n行m个整数．表示science[i][j]；

接下来n行m个整数，表示same_art[i][j]；

接下来n行m个整数，表示same_science[i][j]；

Output

输出为一个整数，表示最大的满意值之和

Sample Input

3 4
13 2 4 13
7 13 8 12
18 17 0 5
8 13 15 4
11 3 8 11
11 18 6 5
1 2 3 4 
4 2 3 2
3 1 0 4
3 2 3 2
0 2 2 1
0 2 4 4

Sample Output

152

Hint

样例说明

1表示选择文科，0表示选择理科，方案如下：

1  0  0  1

0  1  0  0

1  0  0  0

N,M<=100,读入数据均<=500

最小割

我们设把一个点割到S表示这个人选文，割到T表示选理

把S向每个点连一条art的边，表示如果割断这条边，这个人选理，损失选文的收益

把每个点向T连一条science的边，表示如果割断这条边，这个人选文，损失选理的收益

那么对于2,3两个条件该如何处理呢

首先，我们对于每5个相邻的节点，新建一个点。从S向这个点连一条same_art的边，割断这条边，表示他们五个人不都选文，损失这个收益，不割断表示都选文

对于选理，也是新建一个点。从这个点向T连一条same_science的边，割断这条边，表示他们五个人不都选理，损失这个收益，不割断表示都选理

为了防止不割断这条边而不选相同的事情发生，我们把新建节点向5个相邻的节点连inf的边（或把5个相邻的节点连边向新建节点连边），表示该边无法被割断，即不能出现非法的情况

跑最大流

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
int iter[500001],que[500001],hh,tt,cap[500001],nxt[500001],to[500001],g[1000001],level[500001],h[500001],k=1;
const int INF=999999999;
void ins(int u,int v,int c)
{
    nxt[++k]=h[u];to[k]=v;cap[k]=c;h[u]=k;
    nxt[++k]=h[v];to[k]=u;cap[k]=0;h[v]=k;
}
inline int read(){ 
    int x; bool f; char c; 
    for (f=0; (c=getchar())<'0'||c>'9'; f=c=='-'); 
    for (x=c-'0'; (c=getchar())>='0'&&c<='9'; x=(x<<3)+(x<<1)+c-'0'); 
    return f?-x:x; 
} 
bool bfs(int S,int T)
{
    memset(level,0,sizeof(level));
    hh=tt=0;que[tt++]=S;level[S]=1;
    while(hh<tt)
    {
        int u=que[hh++];
        for(int i=h[u];i;i=nxt[i])
        {
            int v=to[i];
            if(cap[i]&&!level[v])
            {
                level[v]=level[u]+1;
                que[tt++]=v;
            }
        }
    }
    if(!level[T])return 0;
    return 1;
}
int dfs(int u,int f,int T)
{
    if(u==T)return f;
    int used=0,w;
    for(int &i=iter[u];i;i=nxt[i])
    {
        int v=to[i];
        if(cap[i]&&level[v]==level[u]+1)
        {
            w=f-used;w=dfs(v,min(w,cap[i]),T);
            if(w)
            {
                cap[i]-=w;cap[i^1]+=w;used+=w;if(used==f)return used;
            }
        }
    }
    return used;
}
int dinic(int S,int T,int y)
{
    int flow=0;
    while(bfs(S,T))
    {
        for(int i=1;i<=y;i++)iter[i]=h[i];
        flow+=dfs(S,INF,T);
    }
    return flow;
}
int main()
{int tot=0;
    int n=read(),m=read();int q=n*m,S=q+1,T=q+2,kk=q+2;
    for(int i=1;i<=n;i++)
    for(int j=1;j<=m;j++)
    {
        int f=read(),r=(i-1)*m+j;tot+=f;
        ins(S,r,f);
    }
    for(int i=1;i<=n;i++)
    for(int j=1;j<=m;j++)
    {
        int f=read(),r=(i-1)*m+j;tot+=f;
        ins(r,T,f);
    }
    for(int i=1;i<=n;i++)
    for(int j=1;j<=m;j++)
    {
        int f=read(),r=(i-1)*m+j;++kk;tot+=f;
        if(i!=n)ins(kk,r+m,INF);
        if(i!=1)ins(kk,r-m,INF);
        if(j!=1)ins(kk,r-1,INF);
        if(j!=m)ins(kk,r+1,INF);
        ins(S,kk,f);ins(kk,r,INF);
    }
    for(int i=1;i<=n;i++)
    for(int j=1;j<=m;j++)
    {
        int f=read(),r=(i-1)*m+j;++kk;tot+=f;
        if(i!=n)ins(r+m,kk,INF);
        if(i!=1)ins(r-m,kk,INF);
        if(j!=1)ins(r-1,kk,INF);
        if(j!=m)ins(r+1,kk,INF);
        ins(kk,T,f);ins(r,kk,INF);
    }
    printf("%d",tot-dinic(S,T,kk));
    return 0;
}