505. The Maze II

時間 2020-06-02

標籤 maze 简体版

原文原文鏈接

原題連接：https://leetcode.com/articles/the-maze-ii/html

個人思路

在作完了第一道迷宮問題 http://www.cnblogs.com/optor/p/8533068.html 後，這第二道迷宮問題就比較簡單了。題意是求最短路徑，因此我以爲使用深度優先搜索不合適（由於深度優先搜索須要遍歷完全部走法以後再取路徑最短的，比較麻煩），而廣度優先搜索則較爲適合這個問題。因此我嘗試寫了下廣度優先搜索的實現：java

import java.util.LinkedList;
import java.util.Queue;

/**
 * Created by clearbug on 2018/2/26.
 */
public class Solution {

    public static void main(String[] args) {
        Solution s = new Solution();
        /**
         * 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
         */
        int[][] board = {
                {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},
        };
        System.out.println(s.hasPath(board, new int[]{0, 4}, new int[]{4, 4}));

        /**
         * 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

         */
        int[][] board2 = {
                {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},
        };
        System.out.println(s.hasPath(board2, new int[]{0, 4}, new int[]{3, 2}));
    }

    public int hasPath(int[][] maze, int[] start, int[] dest) {
        maze[start[0]][start[1]] = 2;

        int[][] dirs = {
                {0, 1},
                {0, -1},
                {-1, 0},
                {1, 0}
        };

        Queue<int[]> queue = new LinkedList<>();
        queue.add(start);

        while (!queue.isEmpty()) {
            int[] s = queue.remove();
            if (s[0] == dest[0] && s[1] == dest[1]) {
                return maze[s[0]][s[1]] - 2;
            }
            for (int[] dir : dirs) {
                int x = s[0] + dir[0];
                int y = s[1] + dir[1];
                while (x >= 0 && y >= 0 && x < maze.length && y < maze[0].length && maze[x][y] != 1) {
                    x += dir[0];
                    y += dir[1];
                }
                if (maze[x - dir[0]][y - dir[1]] == 0) {
                    queue.add(new int[]{x - dir[0], y - dir[1]});
                    maze[x - dir[0]][y - dir[1]] = maze[s[0]][s[1]] + Math.abs(x - dir[0] - s[0]) + Math.abs(y - dir[1] - s[1]);
                }
            }
        }

        return -1;
    }

}

直接在上一題的廣度優先搜索算法實現上修改就行啦！！！下面去看看官方的解法是怎樣的吧！算法