BZOJ 4657 (网络流)

题面

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

分析

本题很容易想到一个费用流做法，但是该算法无法保证炮弹直线前进，这里不再赘述。

正解：

发现对于每一个点，被横向攻击和被纵向攻击有冲突关系，考虑最小割

然后拆点， 每个点拆成两个，分别管横向的路径和纵向的路径

对于每个炮塔，最优的方案显然是打攻击范围内最大的点，因此我们初始的和就是每个炮塔能够攻击到最大的点之和，然后减去最小割

然后分开考虑横着的点和竖着的点。
对于一个纵向攻击的炮塔，对于攻击路径上的每个竖点(x,y)向攻击方向上的下一个点(xx,yy)连边，边权为\(maxv-a[x][y]\),这样割掉这条边之后答案就变成了\(maxv-(maxv-a[x][y])=a[x][y]\)，相当于选这个点(路径上最大值为maxv,a为每个位置的值)

同理对于每个横点(x,y)，攻击方向上的下一个点(xx,yy)向(x,y)连边，边权为\(maxv-a[x][y]\),同理割掉这条边之后相当于不选(xx,yy）而选(x,y)

代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#define maxc 105
#define maxn 100005
#define maxm 2000005
#define INF 0x3f3f3f3f
using namespace std;
struct edge{
    int from;
    int to;
    int next;
    int flow;
}E[maxm<<1];
int head[maxn];
int sz=1;
void add_edge(int u,int v,int w){
//  printf("%d->%d : %d\n",u,v,w);
    sz++;
    E[sz].from=u;
    E[sz].to=v;
    E[sz].next=head[u];
    E[sz].flow=w;
    head[u]=sz;
    sz++;
    E[sz].from=v;
    E[sz].to=u;
    E[sz].next=head[v];
    E[sz].flow=0;
    head[v]=sz;
}

int deep[maxn];
bool bfs(int s,int t){
    for(int i=s;i<=t;i++) deep[i]=0;
    queue<int>q;    
    q.push(s);
    deep[s]=1;
    while(!q.empty()){
        int x=q.front();
        q.pop();
        for(int i=head[x];i;i=E[i].next){
            int y=E[i].to;
            if(E[i].flow&&!deep[y]){
                deep[y]=deep[x]+1;
                q.push(y);
            } 
        }
    }
    if(deep[t]) return 1;
    else return 0;
}

int dfs(int x,int t,int minf){
    if(x==t) return minf;
    int rest=minf,k;
    for(int i=head[x];i;i=E[i].next){
        int y=E[i].to;
        if(E[i].flow&&deep[y]==deep[x]+1){
            k=dfs(y,t,min(rest,E[i].flow));
            rest-=k;
            E[i].flow-=k;
            E[i^1].flow+=k;
            if(rest==0) break;
        }
    }
    return minf-rest;
}

int dinic(int s,int t){
    int now=0,ans=0;
    while(bfs(s,t)){
        while(now=dfs(s,t,INF)) ans+=now;
    }
    return ans;
}
int n,m;
int a[maxc][maxc];
const int dirx[4]={-1,1,0,0},diry[4]={0,0,-1,1};
inline int get_id(int x,int y){
    return m*(x-1)+y;
} 
int main(){
    scanf("%d %d",&n,&m);
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            scanf("%d",&a[i][j]);
        }
    }
    int s=0,t=n*m*2+1;
    int all=0;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            if(a[i][j]<0){
                int k=-a[i][j]-1;
                int maxv=0;
                for(int x=i,y=j;x>0&&x<=n&&y>0&&y<=m;x+=dirx[k],y+=diry[k]){
                    if(a[x][y]>0) maxv=max(maxv,a[x][y]);
                }
                all+=maxv;
                if(k<2) add_edge(s,get_id(i,j),INF);
                else add_edge(get_id(i,j)+n*m,t,INF);
                for(int x=i,y=j;x>0&&x<=n&&y>0&&y<=m;x+=dirx[k],y+=diry[k]){
                    if(x+dirx[k]>0&&x+dirx[k]<=n&&y+diry[k]>0&&y+diry[k]<=m){
                        if(k<2) add_edge(get_id(x,y),get_id(x+dirx[k],y+diry[k]),maxv-max(0,a[x][y]));
                        else add_edge(get_id(x+dirx[k],y+diry[k])+n*m,get_id(x,y)+n*m,maxv-max(0,a[x][y]));
                    }
                }
            }else{
                add_edge(get_id(i,j),get_id(i,j)+n*m,INF); 
            }
        }
    }
    printf("%d\n",all-dinic(s,t));
}

转载于:https://www.cnblogs.com/birchtree/p/10567967.html