ABC 246： E - Bishop 2——Flood Fill + 记忆化方向

题目来源

---

题意：

给出 N*N 的棋盘，每个位置可能有障碍物。
行走规则：

• 每步操作可以往斜着的四个方向走任意格。
• 如果从 (x1, y1) 走到 (x2, y2)，需要保证这条路径中没有障碍物。

一个棋子从起点 (sx, sy) 出发，问最少走多少步能够到达终点 (ex, ey) ？

---

思路：

很明显能够看出来是 bfs 中的洪水填充问题。

对于每个方向，将这个方向中的能走的所有点都放进队列。

对于每个点，先遍历四个方向，再遍历这个方向中的所有点：

• 走到一个点，如果之前走过了，跳过。
• 如果走到障碍物了，那么该方向上障碍物后面的点都不能走，break。

每个点第一个到达所走的步数就是到该点的最少步数。

但是，在这个题中，这样写很大几率会 T。
所以需要用一点记忆化。

注意到，如果之前按照方向 dir 走过一个点 x，那么该方向上其后面的所有点都应该走过了。
那么如果后面再按照这个方向遇到这个点时，虽然跳过了，其后面的所有点虽然不会更新，但还是会遍历一遍。其实没有必要遍历的。

所以可以用一个三维数组来标记每个点是否被走过，是从哪个方向走过的。

• 如果发现当前点走过了，并且是按当前的方向走过的，那么后面的所有点就没必要遍历了，直接break。
• 如果发现当前点没走过，那么把该方向标记为1，更新该点。
• 还有需要注意的是，如果当前点走过，但不是当前的方向，先别急着continue。因为接下来会遍历该方向上后面的所有点，那么也就是该点的这个方向也走过了，将这个方向标记为1。

这样，每个点最多被走四次，复杂度很低~

#include<bits/stdc++.h>
using namespace std;

#define Ios ios::sync_with_stdio(false),cin.tie(0)
#define mem(a,b) memset(a,b,sizeof a)
#define int long long
#define PII pair<int,int>
#define pb push_back
#define fi first
#define se second
#define endl '\n'
//map<int,int> mp;

const int N = 2010, mod = 1e9+7;
int T, n, m;
int a[N][N];
int stx, sty, enx, eny;
int f[N][N], mp[N][N][4];
int dir[4][2] = {{1, 1}, {1, -1}, {-1, 1}, {-1, -1}};

void bfs()
{
	queue<PII> que;
	que.push({stx, sty});
	f[stx][sty] = 1;
	
	while(que.size())
	{
		int x = que.front().fi, y = que.front().se;
		que.pop();
		
		for(int i=0;i<4;i++)
		{
			for(int d=1;;d++)
			{
				int tx = x + d*dir[i][0], ty = y + d*dir[i][1];
				if(tx < 1 || ty < 1 || tx > n || ty > n) break;
				if(a[tx][ty]) break;
				
				if(mp[tx][ty][i]) break;
				else if(f[tx][ty]){
					mp[tx][ty][i] = 1;
					continue;
				}
				
				f[tx][ty] = f[x][y] + 1;
				mp[tx][ty][i] = 1;
				que.push({tx, ty});
				if(tx == enx && ty == eny) return;
			}
		}
	}
}

signed main(){
	Ios;
	cin>>n;
	
	cin>>stx>>sty>>enx>>eny;
	
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=n;j++)
		{
			char c;cin>>c;
			if(c=='#') a[i][j] = 1;
		}
	}
	
	bfs();
	
	cout << f[enx][eny]-1;
	
	return 0;
}

这样记忆化之后，6s 的时限 300多ms 就跑完了~