1036. 逃离大迷宫BFSHard

Posted pre_eminent

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了1036. 逃离大迷宫BFSHard相关的知识,希望对你有一定的参考价值。

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;

 

以上是关于1036. 逃离大迷宫BFSHard的主要内容,如果未能解决你的问题,请参考以下文章

Java小案例-(逃离迷宫)

HDU 1728 逃离迷宫(DFS||BFS)

逃离迷宫(HDU 1728 BFS)

Hdu 1728 逃离迷宫

杭电 逃离迷宫 BFS

HDU1728-逃离迷宫-BFS