luogu P4142 洞穴遇险（最小费用费用流）

P4142 洞穴遇险（费用流）

题目大意

整个洞穴是一个N*N的方格图，每个格子形如。其中X表示从上到下的行数，Y表示从左到右的列数。(1,1)在左上角,(1,N)在右上角，(N,1)在左下角，(N,N)在右下角。

满足X+Y为奇数格子的有一个不稳定度$V_{X,Y}$,X+Y为偶数的格子的不稳定度为00。

ZRQ现在手里恰巧有M个可以支撑洞穴的柱子，柱子的力量可以认为是无穷大。

只要支撑住了一个格子那么这个格子的不稳定度将降为0。

每个柱子是L型的，它除了要占据当前的格子外，还需要占据两个相邻的格子（这三个格子形成L型,可以选择任意方向放置，一共有4个方向）。

柱子占据相邻的格子不会降低其不稳定度（换句话说就是柱子只有在拐角处有力量）。

有些格子的顶已经塌下来了，无法在其位置放置柱子了，这些格子也不能被占据了。这样已经塌了的格子有K个（他们的不稳定度都为0,即使X+Y为奇数，塌下来的格子的不稳定度也会为0）。

ZRQ想问你，在放置一些柱子后 ，最小的不稳定度之和为多少（可以不将M个柱子都放完）。

解题思路

将所有X+Y为偶数的点分为偶数行和奇数行分别从源点向其连边和向虚汇点连接边（如坍塌则不连），对于所有的X+Y为奇数的点，将其拆为两个点，之间连接容量为1，价值为其点的权值的负数。如果这些X+Y为奇数的点为偶数行，则这个点左右的点向这个点拆点后的起点连接边，这个点拆点后的终点向这个点上下的点连边，如为奇数行则这个点上下的点向这个点拆点后的起点连接边，这个点拆点后的终点向这个点左右的点连接边，这些边的容量为1，价值为0。需要注意的是，因为要求尽可能大的支撑值，因此再费用流更新到dis[t]>0后就退出费用流，此时的流量即为最大支撑值，再用总的不稳定值减去最大支撑值即可

AC代码

// luogu-judger-enable-o2
#include<bits/stdc++.h>
using namespace std;
const int maxn=5e3+5;
const int maxm=2e6+5;
const int inf=0x3f3f3f3f;
int val[2505];
int head[maxn];
struct Edge{
    int to,nxt,cost,flow,cap;
}edge[maxm];
int dis[maxn];
bool vis[maxn];
int tol=0;
int N;
int pre[maxn];
void init(int n)
{
    N=n;
    tol=0;
    memset(head,-1,sizeof(head));
}
void AddEdge(int u,int v,int cap,int cost)
{
    edge[tol].to=v;
    edge[tol].cap=cap;
    edge[tol].flow=0;
    edge[tol].cost=cost;
    edge[tol].nxt=head[u];
    head[u]=tol++;
    edge[tol].to=u;
    edge[tol].cap=0;
    edge[tol].flow=0;
    edge[tol].cost=-cost;
    edge[tol].nxt=head[v];
    head[v]=tol++;
}
bool spfa(int s,int t)
{
    for(int i=0;i<=N;i++)
    {
        dis[i]=inf;
        pre[i]=-1;
        vis[i]=false;
    }
    dis[s]=0;
    vis[s]=true;
    queue<int> q;
    q.push(s);
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        vis[u]=false;
        for(int i=head[u];i!=-1;i=edge[i].nxt)
        {
            int v=edge[i].to;
            if(edge[i].cap>edge[i].flow&&dis[v]>dis[u]+edge[i].cost)
            {
                dis[v]=dis[u]+edge[i].cost;
                pre[v]=i;
                if(!vis[v])
                {
                    vis[v]=true;
                    q.push(v);
                }
            }
        }
    }
    if(pre[t]==-1) return false;
    return true;
}
int MCMF(int s,int t)
{
    int ans=0;
    while(spfa(s,t))
    {
        if(dis[t]>0) break;
        int Min=inf;
        for(int i=pre[t];i!=-1;i=pre[edge[i^1].to])
        {
            if(Min>edge[i].cap-edge[i].flow)
                Min=edge[i].cap-edge[i].flow;
        }
        for(int i=pre[t];i!=-1;i=pre[edge[i^1].to])
        {
            edge[i].flow+=Min;
            edge[i^1].flow-=Min;
            ans+=Min*edge[i].cost;
        }
    }
    return ans;
}		
int main()
{
    int n,m,k;
    scanf("%d%d%d",&n,&m,&k);
    int v;
    int ans=0;
    init(2*n*n+2);
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            scanf("%d",&v);
            ans+=v;
            val[(i-1)*n+j]=v;
        }
    }
    int x,y;
    for(int i=1;i<=n;i++)
    for(int j=1;j<=n;j++)
    vis[(i-1)*n+j]=true;
    for(int i=1;i<=k;i++)
    {
        scanf("%d%d",&x,&y);
        vis[(x-1)*n+y]=false;
    }
    int s=0,t=2*n*n+1,tt=2*n*n+2;
    AddEdge(t,tt,m,0);
    int loop=n*n;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            if((i+j)%2==0&&vis[(i-1)*n+j]){if(i%2==0) AddEdge(s,(i-1)*n+j,1,0);else AddEdge((i-1)*n+j,t,1,0);}
            if((i+j)%2==1&&vis[(i-1)*n+j])
            {
                AddEdge((i-1)*n+j,(i-1)*n+j+loop,1,-val[(i-1)*n+j]);
                if(i%2==0)
                {
                    if(i+1<=n)
                    {
                        if(j+1<=n) AddEdge((i-1)*n+j+1,(i-1)*n+j,1,0),AddEdge((i-1)*n+j+loop,i*n+j,1,0);
                        if(j-1>=1) AddEdge((i-1)*n+j-1,(i-1)*n+j,1,0),AddEdge((i-1)*n+j+loop,i*n+j,1,0);
                    }
                    if(i-1>=1)
                    {
                        if(j+1<=n) AddEdge((i-1)*n+j+1,(i-1)*n+j,1,0),AddEdge((i-1)*n+j+loop,(i-2)*n+j,1,0);
                        if(j-1>=1) AddEdge((i-1)*n+j-1,(i-1)*n+j,1,0),AddEdge((i-1)*n+j+loop,(i-2)*n+j,1,0);
                    }
                }
                else
                {
                    if(i+1<=n)
                    {
                        if(j+1<=n) AddEdge(i*n+j,(i-1)*n+j,1,0),AddEdge((i-1)*n+j+loop,(i-1)*n+j+1,1,0);
                        if(j-1>=1) AddEdge(i*n+j,(i-1)*n+j,1,0),AddEdge((i-1)*n+j+loop,(i-1)*n+j-1,1,0);
                    }
                    if(i-1>=1)
                    {
                        if(j+1<=n) AddEdge((i-2)*n+j,(i-1)*n+j,1,0),AddEdge((i-1)*n+j+loop,(i-1)*n+j+1,1,0);
                        if(j-1>=1) AddEdge((i-2)*n+j,(i-1)*n+j,1,0),AddEdge((i-1)*n+j+loop,(i-1)*n+j-1,1,0);
                    }
                }
            }
        }
    }
    printf("%d\n",ans+MCMF(s,tt));
}