bfs寻找最短路径并且打印路径和方向

声明！！！！！
在此之前，我写过一篇使用bfs打印路径的文章，当时使用的是map，肯定是错了，因为
bfs进行扩展的时候每一步肯定有多个节点啦，是不能确定那个节点是最终路径上的。
告诉大家我写错了，真是深深的歉意啊
，I am terribly sorry啊啊啊啊 ，为此我又重新写了一篇正解送给大家，请大家包容
一下我这个小菜鸟吧，万分感谢啦。下面上代码（注意我使用的迷宫矩阵是0和1数据）

import java.util.*;  
public class Main {  
    static Scanner in = new Scanner(System.in);  
    static int m,n,sp,ep;  
    static int[][] vis = new int[105][105];  
    static int[][] ma = new int[105][105];  
    static int[][] dir = {  
            {0,1},{1,0},{0,-1},{-1,0}  
      };   
    static char[] d = {'R','D','L','U'};//方向，后续我会扩展  
    static Queue q = new LinkedList(); 
     static void bfs(Queue q ){  
         int tx=0,ty=0;  
         boolean f=false;  
         while(!f&&!q.isEmpty()){  
               Node te = q.poll();  
           for (int i = 0; i < 4; i++) {  
              tx=te.x+dir[i][0];  
              ty=te.y+dir[i][1];  
            if(tx<0||ty<0||tx>=m||ty>=n||ma[tx][ty]==1)  
                    continue;  
            if(vis[tx][ty]==0&&ma[tx][ty]==0) {  
                vis[tx][ty]=1;    
             Node nw = new Node(tx,ty,te.step+1,te,d[i]);  
             //System.out.println(nw.x+" "+nw.y+" "+nw.step);打印调试使用
                 q.add(nw);   
            }  
            //到达终点  
            if(tx==sp&&ty==ep){  
                f=true;  
                break;                
            }  
          }  
        }  
      } 
     //递归打印路径
     static void print(Node end){
    	 if(end.parent==null){
    	  System.out.println(end.x+" "+end.y+" "+end.dir);
    		 return;
    	  }   	 
        print(end.parent);
       System.out.println(end.x+" "+end.y+" "+end.dir);
     }
    public static void main(String[] args) {           
         while(in.hasNext()) {  
            q.clear();      
            m = in.nextInt();  
            n = in.nextInt();  
            sp= in.nextInt();  
            ep=in.nextInt();  
            if(m==0&&n==0)  
                break;  
            String s;  
            for (int i = 0; i < m; i++) {  
                s=in.next();  
                for (int j = 0; j < s.length(); j++) {  
                    ma[i][j]=s.charAt(j)-48;  
                    vis[i][j]=0;  
                }  
            }  
            vis[0][0]=1;  
            Node st = new Node(0, 0, 0,null,'s');//s代表起始点  
            q.add(st);  
            bfs(q);  
            while(q.size()!=1){  
                q.poll();  
            }  
            System.out.println(q.peek().step);  
            Node end = q.poll();
            print(end);
            //也可以使用下面这个简单方法打印，只不过路径是反的
//            while(end.parent!=null){
//                System.out.println(end.x+" "+end.y);
//                end=end.parent;
//            }
//            System.out.println(end.x+" "+end.y);
        }  
    }  
}  
class Node{  
    int x;  
    int y;  
    int step;  
    Node parent;//保存父节点信息值，以打印路径
    char dir;//每次行进的方向
    Node (){}  
    Node(int x,int y,int step,Node p,char d){  
        this.x=x;  
        this.y=y;  
        this.step=step;  
        this.parent=p;
        this.dir = d;
   } 
 }

分析：思路就是使用递归定义来保存父节点的信息，即从哪一个节点扩展的就是他的父节点，这样最后的路径局可以确定啦