BFS

广度优先遍历

解题思路

void BFS()
{
    定义队列;
    定义备忘录，用于记录已经访问的位置；

    判断边界条件，是否能直接返回结果的。

    将起始位置加入到队列中，同时更新备忘录。

    while (队列不为空) {
        获取当前队列中的元素个数。
        for (元素个数) {
            取出一个位置节点。
            判断是否到达终点位置。
            获取它对应的下一个所有的节点。
            条件判断，过滤掉不符合条件的位置。
            新位置重新加入队列。
        }
    }

}

作者：hank-36
链接：https://leetcode-cn.com/problems/shortest-path-in-binary-matrix/solution/biao-zhun-de-bfsjie-fa-duo-lian-xi-jiu-hui-zhang-w/
来源：力扣（LeetCode）

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 。

示例 1：

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

输出：2

示例 2：
输入：[[0,0,0],[1,1,0],[1,1,0]]

输出：4

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/shortest-path-in-binary-matrix

题解(DFS)

import java.util.*;
class Solution 
{
    public int shortestPathBinaryMatrix(int[][] grid) 
    {
        if(grid[0][0] == 1)
            return -1;
        int rows = grid.length;
        int cols = grid[0].length;
        if(grid[rows-1][cols-1] == 1)
            return -1;
        int[][] directions = {{-1,-1},{-1,0},{-1,1},{0,-1},{0,1},{1,-1},{1,0},{1,1}};
        Queue<int[]> queue = new LinkedList(); //存放下一次可以走到的位置
        queue.add(new int[]{0,0});
        grid[0][0] = 1; //表示到达0,0需要走一步
        while(!queue.isEmpty())
        {
            int[] pos = (int[])queue.remove(); 
            for(int i =0 ;i<8;i++)
            {
                int pos1 = pos[0] + directions[i][0]; //就算出当前要考虑的位置
                int pos2 = pos[1] + directions[i][1];
                //如果grid[pos1][pos2] == 0可以表示前面还没考虑到这个位置并且下一次可以考虑这个位置，可以添加到队列中，如果不为0表示不可以走到这里，或者以前已经走过
                if(pos1>=0 && pos1<rows && pos2>=0 && pos2<cols && grid[pos1][pos2] == 0 ) 
                {
                    queue.add(new int[]{pos1,pos2});
                    grid[pos1][pos2] = grid[pos[0]][pos[1]] + 1;
                    
                }
            }
        }
        if(grid[rows-1][cols-1] == 0)
            return -1;
        return grid[rows-1][cols-1];
    }
}