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;
}