【刷题】BZOJ 4657 tower

Description

Nick最近在玩一款很好玩的游戏，游戏规则是这样的：

有一个n*m的地图，地图上的每一个位置要么是空地，要么是炮塔，要么是一些BETA狗，Nick需要操纵炮塔攻击BETA狗们。

攻击方法是：对于每个炮塔，游戏系统已经给出它可以瞄准的方向(上下左右其中一个），Nick需要选择它的攻击位置，每一个炮塔只能够攻击一个位置，炮塔只能够向着它的瞄准方向上的某个位置发动攻击，当然炮塔也可以不进行攻击。炮塔威力强大，它可以且仅可以消灭目标位置上所有的BETA狗。

出于安全考虑，游戏系统已经保证不存在一个炮塔能够瞄准另外一个炮塔，即对于任意一个炮塔，它所有可能的攻击位置上不存在另外一个炮塔。而且，如果把炮塔的起点和终点称为炮弹的运行轨迹，那么系统不允许两条轨迹相交f包括起点和终点）。

现在，选定目标位置以后，每一个炮塔同时开炮，你要告诉Nick，他最多可以干掉多少BETA狗。

Input

第一行两个正整数n，m，表示地图的规模。

接下来礼行，每行m个整数，0表示空地，-1，-2，一3，-4分别表示瞄准上下左右的炮塔，若为正整数p，则表示该位置有p个BETA狗。

n，m <= 50，每个位置的BETA狗数量不超过999个，保证不存在任意一个炮塔能够瞄准另外一个炮塔

Output

一个正整数，表示Nick最多可以干掉几个BETA狗

Sample Input

3 2

0 9

-4 3

0 -1

Sample Output

9

Solution

一道网络流建模题，有关最小割

首先我们把每个点拆成两个点，网上都称为“横点”和“竖点”，那我们也这样叫

然后横点只管横向的边，竖点只管竖向的边，对于每一个点，它的竖点向横点连一条边权为 \(inf\) 的边

左右攻击的塔和上下攻击的塔分开考虑

对于上下攻击的塔，我们先建立一个超级源点，向所有上下攻击的炮塔的竖点连一条边权为 \(inf\) 的边，然后找到这个塔能打到的最大的贡献，然后从炮塔的竖点开始，每个点只向上面或下面相邻的一个点连边，一直连到最大的贡献所在的位置，方向与炮塔攻击方向相同，边权暂时不管

这样一个炮台连出的边就是它选择一个攻击目标后，所覆盖的范围

对于左右攻击的塔，其实同理。建立一个超级汇点，向所有左右攻击的塔的横点连一条边权为 \(inf\) 的边，但方向是从塔到汇点。每个塔也是一直连到它的最大的贡献所在的位置，但方向都是与塔的攻击方向相反的，边权不管

这样建完一个图后，我们默认每个塔都打的是它所能打到的最大的贡献

但这样显然会相交

而相交的现象放到我们建的图里表达出来就是超级源点与超级汇点是连通的

那么我们要做的就是在使他们不联通的情况下，减去的贡献最小

这就是最小割是怎么来的

然后我们要搞定这最小割是多少，就是我们建边的边权是什么

我们最开始不是默认每个炮台选的是贡献最大的点，那么一开始算的答案就是 \(\sum Max(i)\)

然后我们考虑一个炮台，我们如果割掉其中一条边，这条边的出发点是 \(u\) ，而我们把这条边割掉了，就相当于这个炮台选 \(u\) 点攻击，这时候这个炮台的贡献就变成了 \(val(u)\)，从 \(Max(i)\) 变成 \(val(u)\) 减少了 \(Max(i)-val(u)\) ，那么我们就把这条边的边权赋为这个东西，这样割掉这条边，最后减去答案的时候，就会使这个炮台初始的贡献变成真正的贡献

也就是说

对于每一个上下攻击的炮塔的攻击范围的竖点，我们建的边的边权都是所属炮塔最大的贡献减去这条边的起点 \(u\) 的点权，这样割掉了这条边，就像当于选了 \(u\) 点

对于每一个左右攻击的炮塔的攻击范围的横点，我们建的边的边权都是所属炮塔最大的贡献减去这条边的终点 \(v\) 的点权，这样割掉了这条边，就相当与选了 \(v\) 点

然后对于这个图跑了最小割后，用最开始的答案减去最小化的割，就是最大化的贡献了

#include<bits/stdc++.h>
#define ll long long
#define db double
#define ld long double
const int MAXN=50+10,MAXM=50000+10,inf=0x3f3f3f3f;
int n,m,G[MAXN][MAXN],to[MAXM<<2],nex[MAXM<<2],cap[MAXM<<2],e=1,beg[MAXM],level[MAXM],ans,s,t,tot,cur[MAXM];
std::queue<int> q;
template<typename T> inline void read(T &x)
{
    T data=0,w=1;
    char ch=0;
    while(ch!='-'&&(ch<'0'||ch>'9'))ch=getchar();
    if(ch=='-')w=-1,ch=getchar();
    while(ch>='0'&&ch<='9')data=((T)data<<3)+((T)data<<1)+(ch^'0'),ch=getchar();
    x=data*w;
}
template<typename T> inline void write(T x,char c='\0')
{
    if(x<0)putchar('-'),x=-x;
    if(x>9)write(x/10);
    putchar(x%10+'0');
    if(c!='\0')putchar(c);
}
template<typename T> inline void chkmin(T &x,T y){x=(y<x?y:x);}
template<typename T> inline void chkmax(T &x,T y){x=(y>x?y:x);}
template<typename T> inline T min(T x,T y){return x<y?x:y;}
template<typename T> inline T max(T x,T y){return x>y?x:y;}
inline int id(int x,int y,int z)
{
    return (x-1)*m+y+(z?n*m:0);
}
inline void insert(int x,int y,int z)
{
    to[++e]=y;
    nex[e]=beg[x];
    beg[x]=e;
    cap[e]=z;
    to[++e]=x;
    nex[e]=beg[y];
    beg[y]=e;
    cap[e]=0;
}
inline void build(int x,int y,int dir)
{
    int mp=0,pos=-1;
    G[x][y]=0;
    if(dir==-1)
    {
        insert(s,id(x,y,0),inf);
        for(register int i=x-1;i>=1;--i)
            if(G[i][y]>mp)mp=G[i][y],pos=i;
        if(pos==-1)return ;
        for(register int i=x-1;i>=pos;--i)insert(id(i+1,y,0),id(i,y,0),mp-G[i+1][y]);
    }
    if(dir==-2)
    {
        insert(s,id(x,y,0),inf);
        for(register int i=x+1;i<=n;++i)
            if(G[i][y]>mp)mp=G[i][y],pos=i;
        if(pos==-1)return ;
        for(register int i=x+1;i<=pos;++i)insert(id(i-1,y,0),id(i,y,0),mp-G[i-1][y]);
    }
    if(dir==-3)
    {
        insert(id(x,y,1),t,inf);
        for(register int i=y-1;i>=1;--i)
            if(G[x][i]>mp)mp=G[x][i],pos=i;
        if(pos==-1)return ;
        for(register int i=y-1;i>=pos;--i)insert(id(x,i,1),id(x,i+1,1),mp-G[x][i+1]);
    }
    if(dir==-4)
    {
        insert(id(x,y,1),t,inf);
        for(register int i=y+1;i<=m;++i)
            if(G[x][i]>mp)mp=G[x][i],pos=i;
        if(pos==-1)return ;
        for(register int i=y+1;i<=pos;++i)insert(id(x,i,1),id(x,i-1,1),mp-G[x][i-1]);
    }
    ans+=mp;
}
inline void init()
{
    for(register int i=1;i<=n;++i)
        for(register int j=1;j<=m;++j)insert(id(i,j,0),id(i,j,1),inf);
    s=n*m*2+1,t=n*m*2+2;
    for(register int i=1;i<=n;++i)
        for(register int j=1;j<=m;++j)
            if(G[i][j]<0)build(i,j,G[i][j]),tot++;
}
inline bool bfs()
{
    memset(level,0,sizeof(level));
    level[s]=1;
    q.push(s);
    while(!q.empty())
    {
        int x=q.front();
        q.pop();
        for(register int i=beg[x];i;i=nex[i])
            if(cap[i]&&!level[to[i]])level[to[i]]=level[x]+1,q.push(to[i]);
    }
    return level[t];
}
inline int dfs(int x,int maxflow)
{
    if(x==t||!maxflow)return maxflow;
    int res=0,f;
    for(register int &i=cur[x];i;i=nex[i])
        if(cap[i]&&level[to[i]]==level[x]+1)
        {
            f=dfs(to[i],min(maxflow,cap[i]));
            cap[i]-=f;
            cap[i^1]+=f;
            maxflow-=f;
            res+=f;
            if(!maxflow)break;
        }
    return res;
}
inline int Dinic()
{
    int res=0;
    while(bfs())memcpy(cur,beg,sizeof(cur)),res+=dfs(s,inf);
    return res;
}
int main()
{
    read(n);read(m);
    for(register int i=1;i<=n;++i)
        for(register int j=1;j<=m;++j)read(G[i][j]);
    init();
    if(!tot)write(0,'\n');
    else write(ans-Dinic(),'\n');
    return 0;
}

转载于:https://www.cnblogs.com/hongyj/p/8646446.html