[luogu4142]洞穴遇险——最大费用流

题目大意：

有一个n*n的方阵，当第i行第j列满足(i+j)为偶数时，格点权值为0，为奇数时权值为非负整数。你现在有m个L形状的石头，拐角必须要放在权值不为0的位置，这样放置可以抵消掉拐角处的格子的权值，但是有k个格点不可以放置任何石头，求如何让剩下来的权值总和最小。

思路:

看样子是网络流的题目，但是不会建图，最后发现网络流是用来满足题目限制的，可以多加一个费用流来使得选择的石头覆盖的点得权值总和最大。
考虑网络里如何用流量来满足题目限制，发现一个L形状的石头一定可以从奇数行的空点到偶数行的空点，那么每一个合法的覆盖就成了 （奇数行空点——有权值的点——偶数行空点），同时两端接源点和汇点，连一条流量为1的边，这样空点就保证只可以选一次。同时中间的点拆成两个，确保中间的点的流量只可以为1。
然后就把中间的边的费用设成这个格点的权值，表示这个格点有1的流量的时候，费用就是这个格点的权值，然后就把权值取反跑最小费用最大流就好了。
这里需要注意几点，就是石头只有m个，所以我们还要在源点或者汇点处加一条流量为m的边。
还有就是我们只需要最小费用而不是最大流，由于这里是取反跑的最小费用最大流，每一次跑出来的费用递增，所以最后可能会变成正数，就是根本放不下m个石头的时候为了最大流而退流而使得费用增大为正，所以这里判断是否可以增广的条件是费用为负数。
感谢Hany01教会我dinic版费用流并且帮助我调试些SB错误。
这题的建边是真的麻烦，一定是我太菜了。。。

/*=========================
 * Author : ylsoi
 * Problem : luogu4142
 * Algorithm : mcmf
 * Time : 2018.6.25
 * =======================*/
#include<bits/stdc++.h>

#define REP(i,a,b) for(int i=a;i<=b;++i)
typedef long long ll;

using namespace std;

void File(){
    freopen("luogu4142.in","r",stdin);
    freopen("luogu4142.out","w",stdout);
}

const int maxn=50+10;
const int maxe=maxn*maxn*maxn;
const int inf=1<<30;
int ss,tt,n,m,q,mp[maxn][maxn],cntb,numb[maxn][maxn],ans,tot;
int last[maxe],to[maxe],flow[maxe],cost[maxe],beg[maxn*maxn<<2],cnte=1; 
int dx[5]={0,1,0,-1,0};
int dy[5]={0,0,1,0,-1};
bool cant[maxn][maxn];

void add(int u,int v,int f,int c){
    last[++cnte]=beg[u];
    beg[u]=cnte;
    to[cnte]=v;
    flow[cnte]=f;
    cost[cnte]=c;
}

bool judge(int x,int y){return (x>=1 && x<=n && y>=1 && y<=n && !cant[x][y]);}

void init(){
    scanf("%d%d%d",&n,&m,&q);
    REP(i,1,n)REP(j,1,n){
        scanf("%d",&mp[i][j]);
        if((i+j)%2==0)continue;
        tot+=mp[i][j];
        ++cntb;
        numb[i][j]=n*n+cntb;
        add(n*(i-1)+j,n*n+cntb,1,-mp[i][j]);
        add(n*n+cntb,n*(i-1)+j,0,mp[i][j]);
        //cout<<"("<<n*(i-1)+j<<","<<n*n+cntb<<")"<<endl;
    }
    REP(i,1,q){
        int x,y;
        scanf("%d%d",&x,&y);
        cant[x][y]=1;
    }
    ss=0;tt=n*n+cntb+2;
    REP(i,1,n)REP(j,1,n){
        if(cant[i][j])continue;
        if((i+j)%2)
            REP(k,1,4){
                int xx=i+dx[k],yy=j+dy[k];
                if(!judge(xx,yy))continue;
                if(xx%2){
                    add(n*(xx-1)+yy,n*(i-1)+j,1,0);
                    add(n*(i-1)+j,n*(xx-1)+yy,0,0);
                }
                else{
                    add(numb[i][j],n*(xx-1)+yy,1,0);
                    add(n*(xx-1)+yy,numb[i][j],0,0);
                }
            }
        else{
            if(i%2){
                add(ss,n*(i-1)+j,1,0);
                add(n*(i-1)+j,ss,0,0);
            }
            else{
                add(n*(i-1)+j,tt-1,1,0);
                add(tt-1,n*(i-1)+j,0,0);
            }
        }
    }
    add(tt-1,tt,m,0);
    add(tt,tt-1,0,0);
}

struct mcmf{
    int dis[maxn*maxn<<2],cur[maxn*maxn<<2];
    bool vis[maxn*maxn<<2];
    queue<int>qu;
    bool spfa(){
        memset(dis,63,sizeof(dis));
        dis[ss]=0; vis[ss]=1;
        qu.push(ss);
        while(qu.size()){
            int u=qu.front();
            qu.pop(); vis[u]=0;
            for(int i=beg[u];i;i=last[i]){
                if(!flow[i] || dis[u]+cost[i]>=dis[to[i]])continue;
                dis[to[i]]=dis[u]+cost[i];
                if(!vis[to[i]]){
                    qu.push(to[i]);
                    vis[to[i]]=1;
                }
            }
        }
        return dis[tt]<0;
    }
    int dfs(int u,int gap){
        if(u==tt || !gap)return gap;
        vis[u]=1;
        int sum=0,f;
        for(int &i=cur[u];i;i=last[i]){
            if(vis[to[i]] || dis[to[i]]!=dis[u]+cost[i])continue;
            if((f=dfs(to[i],min(gap,flow[i])))){
                flow[i]-=f;
                flow[i^1]+=f;
                gap-=f;
                sum+=f;
            }
            if(!gap)break;
        }
        vis[u]=0;
        return sum;
    }
    void work(){
        while(spfa()){
            REP(i,ss,tt)cur[i]=beg[i];
            ans+=dfs(ss,inf)*dis[tt];
        }
    }
}T;

int main(){
    File();
    init();
    T.work();
    printf("%d\n",tot+ans);
    return 0;
}