g1001_1100.s1036_escape_a_large_maze.Solution Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of leetcode-in-java21 Show documentation
Java-based LeetCode algorithm problem solutions, regularly updated
There is a newer version: 1.38
package g1001_1100.s1036_escape_a_large_maze;

// #Hard #Array #Hash_Table #Depth_First_Search #Breadth_First_Search
// #2022_02_27_Time_115_ms_(73.46%)_Space_79.4_MB_(60.66%)

import java.util.HashSet;
import java.util.Set;

/**
 * 1036 - Escape a Large Maze\.
 *
 * Hard
 *
 * There is a 1 million by 1 million grid on an XY-plane, and the coordinates of each grid square are `(x, y)`.
 *
 * We start at the source = [s_x, s_y] square and want to reach the target = [t_x, t_y] square. There is also an array of `blocked` squares, where each blocked[i] = [x_i, y_i] represents a blocked square with coordinates (x_i, y_i).
 *
 * Each move, we can walk one square north, east, south, or west if the square is **not** in the array of `blocked` squares. We are also not allowed to walk outside of the grid.
 *
 * Return `true` _if and only if it is possible to reach the_ `target` _square from the_ `source` _square through a sequence of valid moves_.
 *
 * **Example 1:**
 *
 * **Input:** blocked = \[\[0,1],[1,0]], source = [0,0], target = [0,2]
 *
 * **Output:** false
 *
 * **Explanation:** The target square is inaccessible starting from the source square because we cannot move. 
 *
 * We cannot move north or east because those squares are blocked. 
 *
 * We cannot move south or west because we cannot go outside of the grid.
 *
 * **Example 2:**
 *
 * **Input:** blocked = [], source = [0,0], target = [999999,999999]
 *
 * **Output:** true
 *
 * **Explanation:** Because there are no blocked cells, it is possible to reach the target square.
 *
 * **Constraints:**
 *
 * *   `0 <= blocked.length <= 200`
 * *   `blocked[i].length == 2`
 * *   0 <= x_i, y_i < 10⁶
 * *   `source.length == target.length == 2`
 * *   0 <= s_x, s_y, t_x, t_y < 10⁶
 * *   `source != target`
 * *   It is guaranteed that `source` and `target` are not blocked.
**/
public class Solution {
    public boolean isEscapePossible(int[][] blocked, int[] source, int[] target) {
        if (blocked.length == 0) {
            return true;
        }
        Set blocks = new HashSet<>();
        for (int[] b : blocked) {
            if (target[0] * 1000000 + target[1] != b[0] * 1000000 + b[1]) {
                blocks.add(b[0] * 1000000 + b[1]);
            }
        }
        return dfs(blocks, source, source[0], source[1], new HashSet<>(), target)
                && dfs(blocks, target, target[0], target[1], new HashSet<>(), source);
    }

    private boolean dfs(
            Set blocks, int[] start, int i, int j, Set visited, int[] target) {
        if (i < 0
                || j < 0
                || i > 999999
                || j > 999999
                || blocks.contains(i * 1000000 + j)
                || visited.contains(i * 1000000 + j)) {
            return false;
        }
        if (i == target[0] && j == target[1]) {
            return true;
        }
        visited.add(i * 1000000 + j);
        if (visited.size() > blocks.size() * (blocks.size() + 1)) {
            return true;
        }
        return dfs(blocks, start, i + 1, j, visited, target)
                || dfs(blocks, start, i - 1, j, visited, target)
                || dfs(blocks, start, i, j + 1, visited, target)
                || dfs(blocks, start, i, j - 1, visited, target);
    }
}