洛谷

https://www.luogu.org/problemnew/show/P2774

把两个相邻的节点连边，这些边就是要方便最小割割断其他边存在的，容量无穷。

这种类似的问题的话，把二分图的一部分（黑点）连S，容量为其价值，另一部分（白点）连T，容量也是其价值。

因为上面的边存在我们在最小割的时候需要割断一些边表示这个点不被取到。

但是这个和最大权闭合子图有什么不同呢，为什么白色点好像和最大权闭合子图中的负权点得到了类似的待遇？

是不是可以这样转化，先假设获得了所有黑点白点的权值，因为某些黑点的存在你必须去购买它相邻的白点，付出白点权值的代价，所以白点就是负权点。

所以我们要么获得黑色点和他相邻的至多4个白点并付出白点的权值的代价（最小割割断4个白点），要么我们舍弃这个黑色点但不需要购买白点。

！！！

意思就是其实二分图最大独立点集是最大权闭合子图的简化版。

据说还有二分图最小顶点覆盖=二分图顶点数-二分图最大独立点集，不知什么意思。

法克，n和m写反了。

#include<bits/stdc++.h>
using namespace std;
#define ll long long

/* dinic begin */

const int MAXN=10100;
const int MAXM=100010;
const int INF=0x3f3f3f3f;
struct Edge{
    int to,next,cap,flow;
}edge[MAXM];

int tol;
int head[MAXN];

void init(){
    tol=2;
    memset(head,-1,sizeof(head));
}

void addedge(int u,int v,int w){
    edge[tol].to=v;edge[tol].cap=w;edge[tol].flow=0;
    edge[tol].next=head[u];head[u]=tol++;
    edge[tol].to=u;edge[tol].cap=0;edge[tol].flow=0;
    edge[tol].next=head[v];head[v]=tol++;
}

int Q[MAXN];
int dep[MAXN],cur[MAXN],sta[MAXN];
bool bfs(int s,int t,int n){
    int front=0,tail=0;
    memset(dep,-1,sizeof(dep[0])*(n+1));
    dep[s]=0;
    Q[tail++]=s;
    while(front<tail){
        int u=Q[front++];
        for(int i=head[u];i!=-1;i=edge[i].next){
            int v=edge[i].to;
            if(edge[i].cap>edge[i].flow&&dep[v]==-1){
                dep[v]=dep[u]+1;
                if(v==t)
                    return true;
                Q[tail++]=v;
            }
        }
    }
    return false;
}

int dinic(int s,int t,int n){
    //n最后一个节点的编号的下一个编号
    int maxflow=0;
    while(bfs(s,t,n)){
        for(int i=0;i<n;i++)cur[i]=head[i];
        int u=s,tail=0;
        while(cur[s]!=-1){
            if(u==t){
                int tp=INF;
                for(int i=tail-1;i>=0;i--){
                    tp=min(tp,edge[sta[i]].cap-edge[sta[i]].flow);

                }
                maxflow+=tp;
                for(int i=tail-1;i>=0;i--){
                    edge[sta[i]].flow+=tp;
                    edge[sta[i]^1].flow-=tp;
                    if(edge[sta[i]].cap-edge[sta[i]].flow==0)
                        tail=i;
                }
                u=edge[sta[tail]^1].to;

            }
            else if(cur[u]!=-1&&edge[cur[u]].cap>edge[cur[u]].flow
                    &&dep[u]+1==dep[edge[cur[u]].to]){
                sta[tail++]=cur[u];
                u=edge[cur[u]].to;
            }
            else{
                while(u!=s&&cur[u]==-1){
                    u=edge[sta[--tail]^1].to;
                }
                cur[u]=edge[cur[u]].next;
            }
        }
    }
    return maxflow;
}

/* dinic end */

int c[105][105];

int n,m;
int id(int i,int j){
    return (i-1)*m+j;
}

int main(){
    init();
    scanf("%d%d",&n,&m);
    ll sum=0;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            scanf("%d",&c[i][j]);
            sum+=c[i][j];
        }
    }

    int s=0,t=4*n*m+1;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            if((i+j)%2==1){
                //黑点
                addedge(s,id(i,j),c[i][j]);
            }
            else{
                addedge(id(i,j),t,c[i][j]);
            }
        }
    }

    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            if((i+j)%2==1){
                //黑点
                if(i>1){
                    addedge(id(i,j),id(i-1,j),INF);
                }
                if(j>1){
                    addedge(id(i,j),id(i,j-1),INF);
                }
                if(i+1<=n){
                    addedge(id(i,j),id(i+1,j),INF);
                }
                if(j+1<=m){
                    addedge(id(i,j),id(i,j+1),INF);
                }
            }
        }
    }

    int maxflow=dinic(s,t,t+1);
    printf("%lld
",sum-maxflow);

}