1036. 逃离大迷宫【BFS】【Hard】_1036逃离大迷宫 java-CSDN博客

本文链接：https://blog.csdn.net/pre_eminent/article/details/122444758

1036. 逃离大迷宫

难度困难

在一个 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;
}