【LeetCode】1091. 二进制矩阵中的最短路径

一、题目

在一个 N × N 的方形网格中，每个单元格有两种状态：空（0）或者阻塞（1）。

一条从左上角到右下角、长度为 k 的畅通路径，由满足下述条件的单元格 C_1, C_2, ..., C_k 组成：

• 相邻单元格 C_i 和 C_{i+1} 在八个方向之一上连通（此时，C_i 和 C_{i+1} 不同且共享边或角）
• C_1 位于(0, 0)（即，值为 grid[0][0]）
• C_k 位于 (N-1, N-1)（即，值为 grid[N-1][N-1]）
• 如果 C_i 位于 (r, c)，则 grid[r][c] 为空（即，grid[r][c] == 0）

示例 1：

输入：[[0,1],[1,0]]

输出：2

示例 2：

输入：[[0,0,0],[1,1,0],[1,1,0]]

输出：4

提示：

1.1 <= grid.length == grid[0].length <= 100
2.grid[i][j] 为 0 或 1

二、解决

1、暴力

思路： 略。
代码： 略。
时间复杂度： $O(?)$
空间复杂度： $O(?)$

2、DP

思路：

1、状态定义
dp[x][y]：从（0，0）到（x,y）位置的

2、状态方程
dp[i][j] = min{
   dp[new_i][new_j]+1, dp[i][j]},  dp[new_i][new_j]有效 -- 注意上下限 & 八连通

代码： 未通过，暂略。
时间复杂度： $O(n^2)$
空间复杂度： $O(n^2)$

3、BFS

思路：

先附一下BFS模板：

public class TreeNode {
   
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode(int x) {
   
        val = x;
    }
}

public List<List<Integer>> BFS(TreeNode root) {
   

	List<List<Integer>> allResults = new ArrayList<>();
    if (root == null)  return allResults;
    
    Queue<TreeNode> nodes = new LinkedList<>();
    nodes.add(root);
    while (!nodes.isEmpty()) {
   
        int levelSize = nodes.size();
        List<Integer> results = new ArrayList<>();
        for (int i = 0; i < levelSize; i++) {
   
            TreeNode currNode = nodes.poll();
            results.add(currNode.val);
            if (currNode.left != null)  nodes.add(currNode.left);
            if (currNode.right != null)  nodes.add(currNode.right);
        }
        allResults.add(results);
    }
    return allResults;
}

这里原理类似，从左上方向右下方逐层扩展，直到遇到最右下角的位置，返回对应长度。这里需要改动上述模板的地方有：数据结构变了，随之将TreeNode改成directions方向向量。所有的代码块具体内容随之做出合适的改变。

代码：

public class shortestPathBinaryMatrix {
   
    private static int[][] directions = {
   {
   0,1}, {
   0, -1}, {
   1, -1}, {
   1, 0}, {
   1, 1}, {
   -1, -1}