题解：P14065 [PO Final 2022] 对弈 / Laserschack

题目传送门

先警示后人：

我在看题目的时候看成了 \(1 \le r,c \le 4000\)

然后被迫想了一个 \(\operatorname{O}(\operatorname{RC} \ \operatorname{log} \ \operatorname{RC})\) 发现好像有点玄

最后乱加一堆优化跑爆了只能重写

---

正解：

• 对于这个数组考虑 二维 转 一维 ，静态数组存不下
  
  如果喜欢用动态二维数组自然是很好的（）
• 算法上考虑两遍 BFS 直接秒了，下面开始介绍思路

第一遍 BFS：

我们多源 BFS 对所有 R 进行扩展

更新图上每个点最早被烟雾覆盖的时间 \(\operatorname{time[\ ]}\)

BFS 的特性可以保证这样遍历到的每个点确实是正确的

\(\operatorname{O(RC)}\)

第二遍 BFS：

从 A 开始或从 K 开始都无所谓，我喜欢反图就从 K 开始了

• 我们的目标：
  
  找到所有合法路径（即能从 A 到达 K 的路径）最晚被烟雾碰到的那条路，并且求出这条路上最小的 \(\operatorname{time[\ ]}\)

• 实现方式:
  
  从 K 开始遍历四个方向

  如果找到了边界，就 break
  
  如果找到了 o ，说明找到一条子路了，就判断当前子路存的 path_time[ ] 是否小于当前手里搜出来的最小断点，如果是，就拿手里这个更新这个子路的 path_time[ ]
  
  如果找到了 A ，说明走通了一条合法路径，我们拿手里的最小断点直接去 \(\max(\operatorname{ans,current})\)

  而这个 BFS 的队列的存储要使用大根堆的优先队列来尽可能的贪心，就像 dijkstra 选取最小边来扩展
  
  我们从队列里面拿出任意一个点的时候，将他的最早断点与此时的 ans 对比，如果这个最早断点早于 ans ，那么直接可以 continue
  
  这时 \(\operatorname{O(RC \ log \ RC)}\)

• 正确性简证：
  
  激光不经过任何烟雾，从而攻击到国王。
  
  也就是所有 A 到 K 的合法路径上都存在烟雾，求这个最早的时间
  
  转换成不以时间为变量，求所有路径上最早断点最晚的路径，当这个路径被遮住是，其他所有路径也早就被遮住

细节都在代码里了

注释清晰，码风优良

---

\(\mathbb {\LARGE C \large _O \ \Large ^D \normalsize _E}\)

#include<bits/stdc++.h>

using namespace std;

const int N = 4002;
const int dx[5] = {0, 1, -1, 0, 0};
const int dy[5] = {0, 0, 0, 1, -1};

struct SMOKE {
	int x, y;
};

queue< SMOKE >R;//存储R的坐标，用于多源BFS预处理图 

int r, c, in_x, in_y, pth_min;//in_x,in_y存国王的坐标
int a[N << 4], SMoke_TIme[N << 4], vis[N << 4]; //a存图; SMoke_TIme存烟雾的时间层; vis存当前点（只有镜子才会有）的最早断点
int ans = 0;
int x , y, xx, yy, v;

void input(){
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);

	cin >> r>> c;
	for(int i = 1; i <= r; i++){
		for(int j = 1; j <= c; j++){
			SMoke_TIme[c * (i - 1) + j] = -1;
			char ch;
			cin >> ch;
			if(ch == 'o') a[c * (i - 1) + j] = 4;
			if(ch == '.') a[c * (i - 1) + j] = 0;
			if(ch == 'A') a[c * (i - 1) + j] = 1;
			if(ch == 'K') {
					      a[c * (i - 1) + j] = 2;
				in_x = i;
				in_y = j;//存储国王位置
			}
			if(ch == 'R') {
					      a[c * (i - 1) + j] = 3;
				R.push(SMOKE{i, j});//烟雾初始位置入队保存
				SMoke_TIme[c * (i - 1) + j] = 0;
			}
		}
	}
}

void output(){
	cout << ans << endl;
}

void BFS(){//多源BFS预处理图的时间层 

	while( !R.empty()){
		x = R.front().x;
		y = R.front().y;
		R.pop();
		for(int i = 1; i <= 4; i++){//四个方向扩散
			xx = x + dx[i];
			yy = y + dy[i];
			if(xx < 1 or yy < 1 or xx > r or yy > c or SMoke_TIme[c * (xx - 1) + yy] != -1)continue;//边界条件
			//BFS能保证每个点搜到的时候都是距离他最近的烟雾为祖先
			//也就是能保证SMoke_TIme最小
			SMoke_TIme[c * (xx - 1) + yy] = SMoke_TIme[c * (x - 1) + y] + 1;//是自己祖先的下一秒
			R.push(SMOKE{xx, yy});
		}
	}
}

struct path{
	int x, y;
	int v;//到这个镜子的这条路径上的最早阻断点，也就是这条路最早失效的时间
	bool operator <(const path &other)const {
		return v >= other.v;//优先队列取出当前最优解（就是最晚被干掉的合法路径）
	}
};

priority_queue< path >q;

void solve_BFS(){//从国王位置倒着搜所有合法路径 

	for(int i = 1; i <= 4; i++){
		xx = in_x;
		yy = in_y;
		pth_min = SMoke_TIme[c * (xx - 1) + yy];
		while(true){
			xx += dx[i];
			yy += dy[i];
			if(xx < 1 or yy < 1 or xx > r or yy > c)break;//边界条件判断 

			if(a[c * (xx - 1) + yy] == 3) break;//剪枝 

			pth_min = min(pth_min, SMoke_TIme[c * (xx - 1) + yy]);

			if(a[c * (xx - 1) + yy] == 4){//遇到镜子就停止这个方向的初始化
				vis[c * (xx - 1) + yy] = max(vis[c * (xx - 1) + yy], pth_min);
				q.push(path{xx, yy, pth_min});
				break;
			}
			if(a[c * (xx - 1) + yy] == 1){//遇到A就说明可以直接返回这条路线了
				ans = max(ans, pth_min);
				break;
			}
		}
	}

	while(!q.empty()){
		path t = q.top();
		q.pop();
		if(t.v <= ans)continue;//剪枝优化：当前这条路径已经废了，被阻挡的时间比我们已经求出来的还早
		for(int i = 1; i <= 4; i++){
			xx = t.x;
			yy = t.y;
			pth_min = t.v;
			while(true){
				xx += dx[i];
				yy += dy[i];
				if(xx < 1 or yy < 1 or xx > r or yy > c) break;//边界条件判断

				if(a[c * (xx - 1) + yy] == 3)break;//剪枝 

				pth_min = min(pth_min, SMoke_TIme[c * (xx - 1) + yy]);//更新路径 

				if(a[c * (xx - 1) + yy] == 4){
					if(pth_min > vis[c * (xx - 1) + yy]){//如果是更好的子路
						vis[c * (xx - 1) + yy] = pth_min;
						q.push(path{xx, yy, pth_min});
					}
					break;
				}

				if(a[c * (xx - 1) + yy] == 1){//合法路径直接返回
					ans = max(pth_min, ans);
					break;
				}
			}
		}
	}
}

main(void){
	input();

	BFS();

	solve_BFS();

	output();
}