1036. 逃离大迷宫BFSHard
Posted pre_eminent
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了1036. 逃离大迷宫BFSHard相关的知识,希望对你有一定的参考价值。
难度困难
在一个 106 x 106 的网格中,每个网格上方格的坐标为 (x, y)
。
现在从源方格 source = [sx, sy]
开始出发,意图赶往目标方格 target = [tx, ty]
。
数组 blocked
是封锁的方格列表,其中每个 blocked[i] = [xi, yi]
表示坐标为 (xi, yi)
的方格是禁止通行的。
每次移动,都可以走到网格中在四个方向上相邻的方格,只要该方格 不 在给出的封锁列表 blocked
上。
同时,不允许走出网格。
只有在可以通过一系列的移动从源方格 source
到达目标方格 target
时才返回 true
。
否则,返回 false
。
示例 1:
输入:blocked = [[0,1],[1,0]], source = [0,0], target = [0,2] 输出:false 解释: 从源方格无法到达目标方格,因为我们无法在网格中移动。 无法向北或者向东移动是因为方格禁止通行。 无法向南或者向西移动是因为不能走出网格。
示例 2:
输入:blocked = [], source = [0,0], target = [999999,999999] 输出:true 解释: 因为没有方格被封锁,所以一定可以到达目标方格。
提示:
0 <= blocked.length <= 200
blocked[i].length == 2
0 <= xi, yi < 106
source.length == target.length == 2
0 <= sx, sy, tx, ty < 106
source != target
- 题目数据保证
source
和target
不在封锁列表内
思路:
有限步数的广度优先搜索
判断能否从 source 走到 target,
最简单且直观的方法就是从 source 开始进行广度优先搜索,
如果搜索的过程中经过了 target,则说明可以到达。
然而本题中给定的网格规模是 10^6 × 10^6的,
常规的广度优先搜索会达到 O(10^6 × 10^6) = O(10^12)的时间复杂度,远远超出了时间限制。
因此我们必须进行优化。
注意到障碍的个数不超过 200 个,
这说明网格中大部分的位置都不是障碍,只有极少一部分的位置是障碍。
分析从 source 无法走到 target 的情况,无非就是以下两种:
1. source 被障碍完全包围,并且 target 不在包围圈中;
2. target 被障碍完全包围,并且 source 不在包围圈中。
在「障碍的个数不超过 200 个前提下」,
我们可以猜测「包围圈」的大小也不会很大。
也就是说,如果障碍的个数为 n 个,
那么我们希望得到「包围圈」中包含的非障碍位置的数量的上界,
假设其为 limit,那么:
如果我们从 source 开始进行广度优先搜索,搜索到的非障碍位置的数量严格大于 limit,
那么说明 source 一定不在任何包围圈中。
同时,如果从 target 开始进行广度优先搜索也是如此,
那么同样说明 target 一定也不在任何包围圈中。
此时我们就可以断定,一定能从 source 走到 target。
因此我们的目标就是正确估计「包围圈」的上界。
当障碍的个数固定为 n 个时
(我们只考虑 n ≥ 2 的情况,因为如果 n=0,1n=0,1,那么无法形成「包围圈」,任意两个位置都互相可达),
要想使得非障碍位置的数量最大,这些障碍一定是靠着网格的一个角进行包围的,
因为这样可以利用到网格的两条边。
我们假设靠着的是网格的左上角,
那么可以证明,最优的包围方法一定是沿着对角线分布,
即一行放置一个障碍物:
这 n 个位置,此时「包围圈」组成一个等腰直角三角形,如下图所示。
其中包含的非障碍位置的数量为:(n - 1) × n / 2
解答:
/**
* @param number[][] blockArr
* @param number[] source
* @param number[] target
* @return boolean
*/
// 被障碍物困住,死翘翘
const dead = -1;
// 还活着,还有希望
const alive = 0;
// 找到了另一半
const married = 1;
// 四个方向
const d = [[0, 1],[0, -1],[1, 0],[-1, 0]];
// 边界
const len = Math.pow(10, 6);
var isEscapePossible = function(blockArr, source, target)
// 0或者1个障碍无法组成包围圈
if(blockArr.length < 2)
return true;
// 所有障碍物的坐标都存到一个集合里
let blockSet = new Set();
for(let dot of blockArr)
let key = [dot[0], dot[1]].toString();
blockSet.add(key);
// 从起点奔赴终点
let res = bfs(blockArr, source, target, blockSet);
if (res === married)
return true;
else if (res === dead)
return false;
else
// 还活着,就再从终点再到起点,双向奔赴才有意义
let otherWay = bfs(blockArr, target, source, blockSet);
// 只要不是dead
return otherWay != dead;
;
function bfs(blockArr, source, target, blockSet)
let x = source[0];
let y = source[1];
let point = [x, y];
let queue = [];
queue.push(point);
// 用一个set避免重复走
let visitedSet = new Set();
visitedSet.add(point.toString());
// N个障碍物,沿着墙边,最多能围一个直角三角形
let n = blockArr.length;
let maxCircledPoint = Math.floor(n*(n-1)/2);
// 只要队列不为空,并且,走访过的位置不超过最大的被围困数
while(queue.length && maxCircledPoint > 0)
// 进入循环第1步,从队列取出元素
let point = queue.shift();
// 第2步,四个方向
for(let i = 0; i < d.length; i++)
let tmpArr = d[i];
let newPoint = [point[0] + tmpArr[0], point[1] + tmpArr[1]];
// 如果是有效的点:范围内,并且没访问过,并且不是障碍物
let isNewPoint = newPoint[0] >= 0 && newPoint[0] < len && newPoint[1] >= 0 && newPoint[1] < len && !visitedSet.has(newPoint.toString()) && !blockSet.has(newPoint.toString());
if(isNewPoint)
// 如果新的点就是终点,直接返回true
let isTarget = newPoint[0] === target[0] && newPoint[1] === target[1];
if(isTarget)
return married;
// 加入队列,同时 待查找的有效位置 - 1
maxCircledPoint--;
queue.push(newPoint);
// 新的点加入到访问过的set
visitedSet.add(newPoint.toString());
// 循环结束了只有两种可能:
// 队列用完了,但是maxCirclePoint还没找到足够多,说明被困住了
if(maxCircledPoint > 0)
return dead;
return alive;
以上是关于1036. 逃离大迷宫BFSHard的主要内容,如果未能解决你的问题,请参考以下文章