[LeetCode] 490. The Maze 迷宮

 

There is a ball in a maze with empty spaces and walls. The ball can go through empty spaces by rolling up, down, left or right, but it won't stop rolling until hitting a wall. When the ball stops, it could choose the next direction.

Given the ball's start position, the destination and the maze, determine whether the ball could stop at the destination.

The maze is represented by a binary 2D array. 1 means the wall and 0 means the empty space. You may assume that the borders of the maze are all walls. The start and destination coordinates are represented by row and column indexes.

Example 1

Input 1: a maze represented by a 2D array

0 0 1 0 0
0 0 0 0 0
0 0 0 1 0
1 1 0 1 1
0 0 0 0 0

Input 2: start coordinate (rowStart, colStart) = (0, 4)
Input 3: destination coordinate (rowDest, colDest) = (4, 4)

Output: true
Explanation: One possible way is : left -> down -> left -> down -> right -> down -> right.

 

Example 2

Input 1: a maze represented by a 2D array

0 0 1 0 0
0 0 0 0 0
0 0 0 1 0
1 1 0 1 1
0 0 0 0 0

Input 2: start coordinate (rowStart, colStart) = (0, 4)
Input 3: destination coordinate (rowDest, colDest) = (3, 2)

Output: false
Explanation: There is no way for the ball to stop at the destination.

 

Note:

1. There is only one ball and one destination in the maze.
2. Both the ball and the destination exist on an empty space, and they will not be at the same position initially.
3. The given maze does not contain border (like the red rectangle in the example pictures), but you could assume the border of the maze are all walls.
4. The maze contains at least 2 empty spaces, and both the width and height of the maze won't exceed 100.

 

這道題讓咱們遍歷迷宮，可是與以往不一樣的是，此次迷宮是有一個滾動的小球，這樣就不是每次只走一步了，而是朝某一個方向一直滾，直到遇到牆或者邊緣才停下來，博主記得貌似以前在手機上玩過相似的遊戲。那麼其實仍是要用 DFS 或者 BFS 來解，只不過須要作一些修改。先來看 DFS 的解法，用 DFS 的同時最好能用上優化，即記錄中間的結果，這樣能夠避免重複運算，提升效率。這裏用二維記憶數組 memo 來保存中間結果，而後用 maze 數組自己經過將0改成 -1 來記錄某個點是否被訪問過，這道題的難點是在於處理一直滾的狀況，其實也不難，有了方向，只要一直在那個方向上往前走，每次判讀是否越界了或者是否遇到牆了便可，而後對於新位置繼續調用遞歸函數，參見代碼以下：

  

解法一：

class Solution {
public:
    vector<vector<int>> dirs{{0,-1},{-1,0},{0,1},{1,0}};
    bool hasPath(vector<vector<int>>& maze, vector<int>& start, vector<int>& destination) {int m = maze.size(), n = maze[0].size();
        vector<vector<int>> memo(m, vector<int>(n, -1));
        return helper(maze, memo, start[0], start[1], destination[0], destination[1]);
    }
    bool helper(vector<vector<int>>& maze, vector<vector<int>>& memo, int i, int j, int di, int dj) {
        if (i == di && j == dj) return true;
        if (memo[i][j] != -1) return memo[i][j];
        bool res = false;
        int m = maze.size(), n = maze[0].size();
        maze[i][j] = -1;
        for (auto dir : dirs) {
            int x = i, y = j;
            while (x >= 0 && x < m && y >= 0 && y < n && maze[x][y] != 1) {
                x += dir[0]; y += dir[1];
            }
            x -= dir[0]; y -= dir[1];
            if (maze[x][y] != -1) {
                res |= helper(maze, memo, x, y, di, dj);
            }
        }
        return memo[i][j] = res;
    }
};

 

一樣的道理，對於 BFS 的實現須要用到隊列 queue，在對於一直滾的處理跟上面相同，參見代碼以下：

 

解法二：

class Solution {
public:
    bool hasPath(vector<vector<int>>& maze, vector<int>& start, vector<int>& destination) {
        if (maze.empty() || maze[0].empty()) return true;
        int m = maze.size(), n = maze[0].size();
        vector<vector<bool>> visited(m, vector<bool>(n, false));
        vector<vector<int>> dirs{{0,-1},{-1,0},{0,1},{1,0}};
        queue<pair<int, int>> q;
        q.push({start[0], start[1]});
        visited[start[0]][start[1]] = true;
        while (!q.empty()) {
            auto t = q.front(); q.pop();
            if (t.first == destination[0] && t.second == destination[1]) return true;
            for (auto dir : dirs) {
                int x = t.first, y = t.second;
                while (x >= 0 && x < m && y >= 0 && y < n && maze[x][y] == 0) {
                    x += dir[0]; y += dir[1];
                }
                x -= dir[0]; y -= dir[1];
                if (!visited[x][y]) {
                    visited[x][y] = true;
                    q.push({x, y});
                }
            }
        }
        return false;
    }
};

 

Github 同步地址：

https://github.com/grandyang/leetcode/issues/490

 

相似題目：

The Maze II

The Maze III

 

參考資料：

https://leetcode.com/problems/the-maze/

https://leetcode.com/problems/the-maze/discuss/97081/java-bfs-solution

https://leetcode.com/problems/the-maze/discuss/97112/Short-Java-DFS-13ms-Solution

https://leetcode.com/problems/the-maze/discuss/97089/java-dfs-solution-could-anyone-tell-me-how-to-calculate-the-time-complexity

 

LeetCode All in One 題目講解彙總(持續更新中...)