广度优先搜索(BFS)求解最短路径问题

广度优先搜索算法思想

1.从起始点出发，先遍历下一层的所有结点，再遍历下下层的所有结点。（宽度优先）

2.在算法实现中，使用队列（先进先出）存储遍历的结点信息。

计算在网格中从原点到特定点的最短路径长度

Shortest Path in Binary Matrix(Medium)
leetcode

由0，1构成的网格路径，0表示可以通过，1表示不可以通过。

import javafx.util.Pair;

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

public class ShortestPathInBinaryMatrix {
    public static void main(String[] args)
    {
        int[][] aa2 ={{0,0,1},{1,0,1},{1,0,1}};
        int[][] aa3 ={{0,1,0,1},{1,0,1,0},{1,0,1,0},{1,0,1,1}};
        int[][] aa ={{0,1},{1,0}};
        int[][] aa4 ={{0,1},{1,0},{1,0}};
        System.out.println(shortestPathBinaryMatrix(aa4));
    }

    public static int shortestPathBinaryMatrix(int[][] grids) {
        if ( grids == null || grids.length == 0 || grids[0].length==0) {
            return -1;
        }
        int PathLength=0;
        int m=grids.length,n=grids[0].length;
        int [][] direction={{-1,-1},{-1,0},{-1,1},{0,-1},{0,1},{1,-1},{1,0},{1,1}}; //定义8个方向
        Queue<Pair<Integer,Integer>> q1=new LinkedList<>(); //实现链表，使用Pair存储元素的行列索引
        q1.add(new Pair<>(0,0) ); //添加起始点
        while(!q1.isEmpty())
        {
            int size=q1.size();
            PathLength++;
            while(size-- > 0)
            {
                Pair<Integer,Integer> cur=q1.poll();
                int cr=cur.getKey(),cl=cur.getValue();

                if(grids[cr][cl]==1) //判断点是否可走或是否已经走过！
                {
                    continue;
                }
                if(cr==m-1 && cl==n-1)
                {
                    return PathLength;
                }
                
                grids[cr][cl]=1; //标记为已经走过了
                for (int[] d :direction) //寻找8个方向中能寻走的点，去除越界的点
                {
                    int nr=cr+d[0],nl=cl+d[1];
                    if(nr<0||nr>=m||nl<0||nl>=n)
                    {
                        continue;
                    }
                    q1.add(new Pair<>(nr,nl));
                }
            }

        }

        return -1;
    }



}