505. The Maze II

Posted optor

tags:

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

原题链接:https://leetcode.com/articles/the-maze-ii/

我的思路

在做完了第一道迷宫问题 http://www.cnblogs.com/optor/p/8533068.html 后,这第二道迷宫问题就比较简单了。
题意是求最短路径,所以我觉得使用深度优先搜索不合适(因为深度优先搜索需要遍历完所有走法之后再取路径最短的,比较麻烦),而广度优先搜索则较为适合这个问题。所以我尝试写了下广度优先搜索的实现:

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;
    }

}

直接在上一题的广度优先搜索算法实现上修改就行啦!!!下面去看看官方的解法是怎样的吧!

官方方法一:深度优先搜索

这次就不抄代码了,只想说官方提供的答案就是思路清晰,代码简介!

官方方法二:广度优先搜索

感觉这里的广度优先搜索算法实现里面稍微有点不妥啊,貌似还不如我的实现呢哈哈

以上是关于505. The Maze II的主要内容,如果未能解决你的问题,请参考以下文章

[LC] 505. The Maze II

The Maze II

[LeetCode] The Maze II 迷宫之二

LeetCode 499. The Maze III

490. The Maze

The Maze