方格取数(网络流)

题目链接：ヾ(≧∇≦*)ゝ

大致题意：给你一个\(n*m\)的矩阵，可以取任意多个数，但若你取了一个数，那么这个数上下左右的数你就都不能取，问能取到的最大值是多少。

Solution:

首先，我们可以把矩阵上的点都染成两种颜色(第一个点为黑色，它会影响的点为白色，这样做下去)。

那么我们就可以得到一个二分图，此时我们注意到，我们要做的是把这个二分图按照冲突关系分为两个点集且要最优。

再结合数据范围，算法就很显然了。网络流最小割。

具体建图步骤：

源点与所有的黑点连边，容量为该点点权，白点与汇点连边，容量为该点点权。

再把所有的黑点和与该黑点产生冲突的白点连边，容量为inf

这样我们得到的最小割就是满足条件的需要舍弃的最小值。答案就是全部值-舍弃值。

最后再根据最小割=最大流这一性质，就能很快的做出此题了

需要注意的是，此题为\(m\)行\(n\)列

Code:

#include<queue>
#include<cstdio>
#include<ctype.h>
#include<cstring>
#include<algorithm>
#define N 40001
#define inf 1926081700
using namespace std;
int dx[4]={0,1,0,-1};
int dy[4]={1,0,-1,0};
int n,m,mp[101][101];
int S,T,ans,cnt=1,head[N/4+11];
struct Edge{int nxt,to,val;}edge[N*2+9];
void ins(int x,int y,int z){
    edge[++cnt].nxt=head[x];edge[cnt].to=y;
    edge[cnt].val=z;head[x]=cnt;
}
namespace Network_Flow{
    queue<int> q;
    int maxflow,dep[N/4+11];
    int bfs(){
        memset(dep,0,sizeof(dep));
        q.push(S);dep[S]=1;
        while(!q.empty()){
            int x=q.front();q.pop();
            for(int i=head[x];i;i=edge[i].nxt){
                int y=edge[i].to;
                if(edge[i].val&&!dep[y]){
                    dep[y]=dep[x]+1;
                    q.push(y);
                }
            }
        }
        return dep[T];
    }
    int dfs(int x,int rest){
        if(x==T||rest<=0) return rest;
        int flow=0;
        for(int i=head[x];i;i=edge[i].nxt){
            int y=edge[i].to,v=edge[i].val;
            if(dep[y]==dep[x]+1){
                int now=dfs(y,min(rest,v));
                edge[i].val-=now;
                edge[i^1].val+=now;
                flow+=now;rest-=now;
                if(rest<=0) break;
            }
        }
        return flow;
    }
    int dinic(){
        while(bfs()) maxflow+=dfs(S,inf);
        return maxflow;
    }
}
int num(int x,int y){return (x-1)*n+y;}
void Ins(int x,int y){
    for(int i=0;i<4;i++){
        int nx=x+dx[i],ny=y+dy[i];
        if(nx>0&&nx<=m&&ny>0&&ny<=n){
            ins(num(x,y),num(nx,ny),inf);
            ins(num(nx,ny),num(x,y),0);
        }
    }
}
int read(){
    int x=0,f=1;char ch=getchar();
    while(!isdigit(ch)){if(ch=='-')f=-f;ch=getchar();}
    while(isdigit(ch)){x=x*10+ch-48;ch=getchar();}
    return x*f;
}
int main(){
    m=read(),n=read();
    S=n*m+1;T=S+1;
    using namespace Network_Flow;
    for(int i=1;i<=m;i++)
        for(int j=1;j<=n;j++)
            mp[i][j]=read(),ans+=mp[i][j];
    for(int i=1;i<=m;i++)
        for(int j=1;j<=n;j++)
            if(!((i+j)%2)){
                ins(S,num(i,j),mp[i][j]);
                ins(num(i,j),S,0);Ins(i,j);
            }else{
                ins(num(i,j),T,mp[i][j]);
                ins(T,num(i,j),0);
            }
    printf("%d",ans-dinic());
    return 0;
}