JZOJ 5602.【NOI2018模拟3.26】Cti

JZOJ 5602.【NOI2018模拟3.26】Cti

Description

　　有一个 \(n×m\) 的地图，地图上的每一个位置可以是空地，炮塔或是敌人。你需要操纵炮塔消灭敌人。
　　对于每个炮塔都有一个它可以瞄准的方向，你需要在它的瞄准方向上确定一个它的攻击位置，当然也可以不进行攻击。一旦一个位置被攻击，则在这个位置上的所有敌人都会被消灭。
　　保证对于任意一个炮塔，它所有可能的攻击位置上不存在另外一个炮塔。
　　定义炮弹的运行轨迹为炮弹的起点和终点覆盖的区域。你需要求出一种方案， 使得没有两条炮弹轨迹相交。

Input

　　第一行两个整数 \(n,m\)；
　　接下来 n 行，每行 m 个整数，$0 \(表示空地，\)-1，-2，-3，-4\(分别表示瞄准上下左右的炮塔，正整数\) p$ 表示表示此位置有 $p $个敌人。

Output

　　输出仅一行一个整数表示答案。

Sample Input

3 2
0 9
-4 3
0 -1

Sample Output

9

Hint

【样例输入2】
4 5
0 0 -2 0 0
-4 0 5 4 0
0 -4 3 0 6
9 0 0 -1 0
【样例输出2】
12
【数据范围与约定】
对于前$ 20 %$ 的数据，\(n, m ≤ 5\)；
　　对于另$ 20 %$ 的数据，朝向上下的炮塔至多有 \(2\) 个；
　　对于另 \(20 \%\)的数据，至多有$ 6 $个炮塔；
　　对于 \(100 \%\) 的数据，\(1 ≤ n, m ≤ 50\)，每个位置的敌人数量 \(< 1000\)。

比较巧妙的网络流。

首先我们要注意这句话“ 保证对于任意一个炮塔，它所有可能的攻击位置上不存在另外一个炮塔。”，所以只有攻击方向垂直的炮塔之间可能相互影响。

所以我们就可以将按攻击方向将图分成两部分。

这种有限制的最优化我们一般的套路就是：先不考虑限制算出最优解\(ans\)，然后用冲突建边跑最小割，答案就是\(ans-\)最小割。

显然不考虑限制情况的话答案就是每个点能取到的最大值之和。然后我们考虑如何将冲突建边。

我们将地图上每个点拆成两个点，表示竖向的点和横向的点。由竖向的点向横向的点一条\(\infty\)的边。对于一个炮台，假设他是竖向（以向上为例）的炮塔，我们先从\(S\)向它连一条\(\infty\)的边，然后从它上面的每一个点都向其上方的第一个点连边，直到遇到边界或者另一个炮台为止；横向的类似，只不过我们连的都是反向的边，然后在向\(T\)连一条\(\infty\)的边。一个冲突就是一条\(S\to T\)的路径。

考虑我们上述的相邻的边的流量该设多大。假设一个竖向炮塔能得到的最大值为\(mx\)，它连了一条路径\((a_1\to a_2...a_{k-1}\to a_k)\)则第\(i\)条边的容量为\(mx-val_{a_i}\)。因为假设我们割了第\(i\)条边，则我们选择的攻击对象为\(a_i\)，所以权值为\(mx-val_{a_i}\)。对于横向的炮台，第\(i\)条边的权值为\(val_{a_{i+1}}\)，同理。

代码：

#include<bits/stdc++.h>
#define ll long long
#define N 55

using namespace std;
inline int Get() {int x=0,f=1;char ch=getchar();while(ch<'0'||ch>'9') {if(ch=='-') f=-1;ch=getchar();}while('0'<=ch&&ch<='9') {x=(x<<1)+(x<<3)+ch-'0';ch=getchar();}return x*f;}

int n,m;
int id[N][N],tot;
int rk[N][N];
int w[N][N];
int val[N][N];
int S,T;
int dx[]={0,-1,1,0,0},dy[]={0,0,0,-1,1};
int d[N][N];
struct road {int to,next,f;}s[N*N<<3];
int h[N*N<<2],cnt=1;
void add(int i,int j,int f) {
    s[++cnt]=(road) {j,h[i],f};h[i]=cnt;
    s[++cnt]=(road) {i,h[j],0};h[j]=cnt;
}
int ans;
int dis[N*N<<2];
queue<int>q;
bool bfs() {
    memset(dis,0x3f,sizeof(dis));
    dis[S]=0;
    q.push(S);
    while(q.size()) {
        int v=q.front();q.pop();
        for(int i=h[v];i;i=s[i].next) {
            int to=s[i].to;
            if(s[i].f&&dis[to]>dis[v]+1) {
                dis[to]=dis[v]+1;
                q.push(to);
            }
        }
    }
    return dis[T]<1e9;
}
int dfs(int v,int maxf) {
    if(v==T) return maxf;
    int ret=0;
    for(int i=h[v];i;i=s[i].next) {
        int to=s[i].to;
        if(s[i].f&&dis[to]==dis[v]+1) {
            int dlt=dfs(to,min(maxf,s[i].f));
            s[i].f-=dlt;
            s[i^1].f+=dlt;
            ret+=dlt;
            maxf-=dlt;
            if(!maxf) return ret;
        }
    }
    return ret;
}
int dinic() {
    int ans=0;
    while(bfs()) {
        while(1) {
            int tem=dfs(S,1e9);
            if(!tem) break;
            ans+=tem;
        }
    }
    return ans;
}

int main() {
    n=Get(),m=Get();
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
            w[i][j]=Get();
    tot=n*m;
    for(int i=1;i<=n;i++) {
        for(int j=1;j<=m;j++) {
            rk[i][j]=(i-1)*m+j;
            if(w[i][j]<0) d[i][j]=-w[i][j];
            add(rk[i][j],rk[i][j]+tot,1e9);
        }
    }
    
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
            val[i][j]=max(0,w[i][j]);
    S=0,T=tot*2+1;
    for(int i=1;i<=n;i++) {
        for(int j=1;j<=m;j++) {
            if(w[i][j]==-1||w[i][j]==-2) {
                add(S,rk[i][j],1e9);
                int mx=0;
                int a=i,b=j;
                for(;;) {
                    a+=dx[d[i][j]],b+=dy[d[i][j]];
                    if(a>n||a<1||b>m||b<1||w[a][b]<0) break;
                    mx=max(mx,w[a][b]);
                }
                ans+=mx;
                for(a-=dx[d[i][j]],b-=dy[d[i][j]];;) {
                    if(a==i&&b==j) break;
                    int prex=a-dx[d[i][j]],prey=b-dy[d[i][j]];
                    add(rk[prex][prey],rk[a][b],mx-val[prex][prey]);
                    a=prex,b=prey;
                }
            } else if(w[i][j]==-3||w[i][j]==-4) {
                add(rk[i][j]+tot,T,1e9);
                int mx=0;
                int a=i,b=j;
                for(;;) {
                    a+=dx[d[i][j]],b+=dy[d[i][j]];
                    if(a>n||a<1||b>m||b<1||w[a][b]<0) break;
                    mx=max(mx,w[a][b]);
                }
                ans+=mx;
                for(a-=dx[d[i][j]],b-=dy[d[i][j]];;) {
                    if(a==i&&b==j) break;
                    int prex=a-dx[d[i][j]],prey=b-dy[d[i][j]];
                    add(rk[a][b]+tot,rk[prex][prey]+tot,mx-val[prex][prey]);
                    a=prex,b=prey;
                }
            }
        }
    }
    cout<<ans-dinic();
    return 0;
}

转载于:https://www.cnblogs.com/hchhch233/p/10601058.html