【GDSOI2017模拟4.13】炮塔（最小割）

Description

A君正在玩一款战略游戏，游戏中的规则是这样的：

给定一个n*m的地图，地图上每一个位置要么是空地，要么是炮塔，要么有若干数量的敌人。现在A君要操控炮塔攻击这些敌人。

对于每个炮塔，它们的攻击方向已经确定(上下左右其中一个)，A君只需要为每个炮塔指定攻击位置。每一个炮塔只能朝它攻击方向上的某个位置进行攻击，每个炮塔只能攻击一次，当然，炮塔也可以不进行攻击。炮塔对一个位置攻击后，位置上的所有敌人都会被消灭。

现在，游戏已经保证不存在一个炮塔能够攻击另一个炮塔的情况。但是，若把炮塔的位置与其攻击位置间的连线称为炮弹的运行轨迹，那么A君的攻击方案要保证不存在两条轨迹相交。

在端点处(即攻击了同一个位置)也算相交，下图是一个相交的例子:

现在每个炮塔选定攻击位置(或是不攻击)后，所有炮塔将会同时开炮进行攻击，请你告诉A君，他一次最多可以消灭多少敌人。

Solution

这道题一看就知道是最小割，但是连边有点难想。
首先个割掉一条边就表示要攻击这个地方。
首先很容易想到的就是，一串连过去，我们先保留这样的连边，然后在修改。
然后竖着的情况我们从炮台开始，但是假如横着的情况也从炮台开始会发生什么？就是竖着的可能把横着的前面的给连上了，所以我们考虑横着的情况就从边界向炮台连边。（因为横着的边反向过，那么竖着边的边权为连来方向，横着边边权为连向方向）
然后我们还会发现一个问题，如果从一个点竖着开始，往横向折了一下，然后又竖着折了一下，然后又横着折，这样折多次明显是错的，所以我们现在要保证最多只折一次，那么我们把方向横竖拆点，横着连横着，竖着连竖着，最后每个横着的向竖着连一条边就好了。
然后跑一边最大流（=最小割）就好了

Code

#include<iostream>
#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<math.h>
#define fo(i,a,b) for(i=a;i<=b;i++)
#define fod(i,a,b) for(i=a;i>=b;i--)
#define rep(i,a) for(i=first[a];i;i=next[i])
using namespace std;
const int maxn=1e5+7,inf=0x7fffffff;
int i,j,k,l,t,n,m,ans,da;
int a[57][57];
int first[maxn*2],last[maxn*2],next[maxn*2],chang[maxn*2],fan[maxn*2],num;
int d[maxn],data[maxn],x,y,S,T;
int de(int x,int y,int z){return (x-1)*m+y+n*m*z;}
void add(int x,int y,int z){
    last[++num]=y,next[num]=first[x],first[x]=num,chang[num]=z,fan[num]=num+1;
    last[++num]=x,next[num]=first[y],first[y]=num,chang[num]=0,fan[num]=num-1;
}
int dinic(int x,int y){
    if(x==T)return y;
    int i,j,p=0;
    rep(i,x){
        if(chang[i]&&d[last[i]]==d[x]+1){
            j=dinic(last[i],min(y,chang[i]));
            if(j){
                chang[i]-=j,chang[fan[i]]+=j;
                p+=j,y-=j;if(!y)break;
            }
        }
    }
    if(!p)d[x]=-1;
    return p;
}
bool bfs(){
    int head=0,tail=1,i,now;
    memset(d,0,sizeof(d));d[data[1]=S]=1;
    while(head<tail){
        now=data[++head];
        rep(i,now){
            if(chang[i]&&!d[last[i]]){
                data[++tail]=last[i];
                d[last[i]]=d[now]+1;
            }
        }
    }
    return d[T]!=0;
}
int main(){
    freopen("tower.in","r",stdin);
    freopen("tower.out","w",stdout);
    scanf("%d%d",&n,&m);
    fo(i,1,n)fo(j,1,m)scanf("%d",&a[i][j]);
    S=0,T=n*m*2+1;
    fo(i,1,n){
        fo(j,1,m){
            add(de(i,j,1),de(i,j,0),inf);
            if(a[i][j]>=0)continue;
            if(a[i][j]==-1){
                da=0;fo(k,1,i)da=max(da,a[k][j]);
                add(S,de(i,j,1),inf);a[1][j]=max(0,a[1][j]);
                add(de(1,j,1),T,da-a[1][j]);
                ans+=da;x=i;
                while(x-1>0){
                    x--;
                    a[x+1][j]=max(0,a[x+1][j]);
                    add(de(x+1,j,1),de(x,j,1),da-a[x+1][j]);
                }
            }
            else if(a[i][j]==-2){
                da=0;fo(k,i,n)da=max(da,a[k][j]);
                add(S,de(i,j,1),inf);a[n][j]=max(0,a[n][j]);
                add(de(n,j,1),T,da-a[n][j]);
                ans+=da;x=i;
                while(x+1<=n){
                    x++;
                    a[x-1][j]=max(0,a[x-1][j]);
                    add(de(x-1,j,1),de(x,j,1),da-a[x-1][j]);
                }
            }
            else if(a[i][j]==-3){
                da=0;fo(k,1,j)da=max(da,a[i][k]);a[i][1]=max(0,a[i][1]);
                add(S,de(i,1,0),da-a[i][1]);
                add(de(i,j,0),T,inf);
                ans+=da;y=j;
                while(y-1>0){
                    y--;
                    a[i][y+1]=max(a[i][y+1],0);
                    add(de(i,y,0),de(i,y+1,0),da-a[i][y+1]);
                }
            }
            else{
                da=0;fo(k,j,m)da=max(da,a[i][k]);a[i][m]=max(0,a[i][m]);
                add(S,de(i,m,0),da-a[i][m]);
                add(de(i,j,0),T,inf);
                ans+=da;y=j;
                while(y+1<=m){
                    y++;
                    a[i][y-1]=max(a[i][y-1],0);
                    add(de(i,y,0),de(i,y-1,0),da-a[i][y-1]);
                }
            }
        }
    }
    while(bfs())ans-=dinic(S,inf);
    printf("%d\n",ans);
}