BFS 求最短路径问题

如果将深度搜索理解为一条道走到黑，广度搜索则是在将一个路口的所有分叉口尝试完一遍，从起点开始通过一层一层找到终点，寻找最短路径。
以下的代码是求从(startx,starty)点开始到终点（p,q）点的最短路径。

package pratice;
import java.util.*;

class note{
    public int x,y,s; // x横坐标，y纵坐标，s步数；
}
public class bfs1 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
      int[][] next={{0,1},{1,0},{0,-1},{-1,0}};
     note[] que = new note[2051];
     for(int i=1;i<2051;i++){    //需对数组里的每个对象都进行初始化并创建，否则会出现空指针的问题
         que[i] = new note();
     }
     int[][] a = new int[51][51];
    int[][] book = new int[51][51];
    int head,tail;
    int i,j,k,n,m,startx,starty,p,q,tx,ty,flag;

    Scanner input = new Scanner(System.in);
    n=input.nextInt();
    m=input.nextInt();
    for(i=1;i<=n;i++){
        for(j=1;j<=m;j++){
            a[i][j]=input.nextInt();
        }
    }
    startx=input.nextInt();
    starty=input.nextInt();
    p=input.nextInt();
    q=input.nextInt();

    head=tail=1;
    que[tail].x=startx;
    que[tail].y=starty;
    que[tail].s=0;
    tail++;
    book[startx][starty]=1;

    flag=0;
    while(head<tail){
        for(k=0;k<4;k++){
            tx=que[head].x + next[k][0];
            ty=que[head].y + next[k][1];
            if(tx>n || tx<1 || ty>m || ty<1) continue;
            if(a[tx][ty]==0 && book[tx][ty]==0){
                book[tx][ty]=1;
                que[tail].x=tx;
                que[tail].y=ty;
                que[tail].s=que[head].s+1;
                tail++;
            }
            if(tx==p && ty==q){
                flag=1;
                break;
            }
        }
        if(flag==1) break;
        head++;
    }
    System.out.println(que[tail-1].s);
    }

}

在广度搜索里是用了队列，每次走到一个点时按顺时针方向（即右、下、左、上）的方向来寻找每一点的下一层，且利用book数组来标记每个点是否已被遍历过，因为有些点可能有多个父结点，即可从许多点走到。每当一个点的四个方向都尝试过，则从队头删除该结点（即head++），最终输出que[tail-1].s则可就出最短路径，因为tail会指向终点的下一个结点，所以是tail-1点的步数。