bzoj4657 tower

Description

---

Nick最近在玩一款很好玩的游戏，游戏规则是这样的：
有一个n*m的地图，地图上的每一个位置要么是空地，要么是炮塔，要么是一些BETA狗，Nick需
要操纵炮塔攻击BETA狗们。
攻击方法是：对于每个炮塔，游戏系统已经给出它可以瞄准的方向(上下左右其中一个），Nick需要
选择它的攻击位置，每一个炮塔只能够攻击一个位置，炮塔只能够向着它的瞄准方向上的某个位置发
动攻击，当然炮塔也可以不进行攻击。炮塔威力强大，它可以且仅可以消灭目标位置上所有的BETA狗。
出于安全考虑，游戏系统已经保证不存在一个炮塔能够瞄准另外一个炮塔，即对于任意一个炮
塔，它所有可能的攻击位置上不存在另外一个炮塔。而且，如果把炮塔的起点和终点称为炮弹的运行
轨迹，那么系统不允许两条轨迹相交f包括起点和终点）。
现在，选定目标位置以后，每一个炮塔同时开炮，你要告诉Nick，他最多可以干掉多少BETA狗。

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

来自 https://www.lydsy.com/JudgeOnline/problem.php?id=4657

Solution

---

有一个神秘的声音呼唤着我写网络流，于是我就点开了这道题

显然只有横竖两种炮台会冲突。把一个点拆成横点、竖点，其中s向竖点连边容量为INF，横点向t连边容量为INF，竖点向横点连边容量为INF，这样保证一个点不能同时被横竖打到
对于横向的炮台找到方向上最大值mx，把攻击范围内的相邻点连边，容量为mx-终点价值，方向与攻击方向相反
对于竖向的炮台找到方向上最大值mx，把攻击范围内的相邻点连边，容量为mx-起点价值，方向与攻击方向相同

最小割的答案一般是先求最优和，再减去最小割，这时候就能发现容量的设置十分科学了

Code

---

#include <stdio.h>
#include <string.h>
#include <algorithm>
#define rep(i,st,ed) for (int i=st;i<=ed;++i)
#define fill(x,t) memset(x,t,sizeof(x))

const int INF=0x3f3f3f3f;
const int N=5005;
const int E=600005;
const int L=205;

struct edge {int x,y,w,next;} e[E];

int a[L][L],dx[4]={-1,1,0,0},dy[4]={0,0,-1,1};
int queue[N],dis[N];
int ls[N],n,m,edCnt=1;

void add_edge(int x,int y,int w) {
    e[++edCnt]=(edge) {x,y,w,ls[x]}; ls[x]=edCnt;
    e[++edCnt]=(edge) {y,x,0,ls[y]}; ls[y]=edCnt;
}

int get(int x,int y,int z) {
    return (z-1)*n*m+(x-1)*m+y;
}

bool bfs(int st,int ed) {
    int head=1,tail=1; queue[tail]=st;
    fill(dis,-1); dis[st]=1;
    while (head<=tail) {
        int now=queue[head++];
        if (now==ed) return true;
        for (int i=ls[now];i;i=e[i].next) {
            if (e[i].w>0&&dis[e[i].y]==-1) {
                dis[e[i].y]=dis[now]+1;
                queue[++tail]=e[i].y;
            }
        }
    }
    return false;
}

int find(int now,int ed,int mn) {
    if (now==ed||!mn) return mn;
    int ret=0;
    for (int i=ls[now];i;i=e[i].next) {
        if (e[i].w>0&&dis[now]+1==dis[e[i].y]) {
            int d=find(e[i].y,ed,std:: min(e[i].w,mn-ret));
            e[i].w-=d; e[i^1].w+=d;
            ret+=d;
            if (mn==ret) break;
        }
    }
    return ret;
}

int dinic(int st,int ed) {
    int ret=0;
    for (;bfs(st,ed);) ret+=find(st,ed,INF);
    return ret;
}

int main(void) {
    scanf("%d%d",&n,&m);
    rep(i,1,n) rep(j,1,m) scanf("%d",&a[i][j]);
    int ans=0;
    rep(i,1,n) rep(j,1,m) {
        if (a[i][j]<0) {
            int k=-1-a[i][j],mx=0;
            if (k<2) add_edge(0,get(i,j,1),INF);
            else add_edge(get(i,j,2),n*m*2+1,INF);

            for (int p=i,q=j;p!=0&&p!=n+1&&q!=0&&q!=m+1;p+=dx[k],q+=dy[k]) {
                mx=std:: max(mx,std:: max(a[p][q],0));
            }
            for (int p=i,q=j;p!=0&&p!=n+1&&q!=0&&q!=m+1;p+=dx[k],q+=dy[k]) {
                if (k<2) add_edge(get(p,q,1),get(p+dx[k],q+dy[k],1),mx-std:: max(a[p][q],0));
                else add_edge(get(p+dx[k],q+dy[k],2),get(p,q,2),mx-std:: max(a[p][q],0));
            }
            ans+=mx;
        } else add_edge(get(i,j,1),get(i,j,2),INF);
    }
    printf("%d\n", ans-dinic(0,n*m*2+1));
    return 0;
}