一个求迷宫入口到出口最近距离的程序 JAVA版本

本文给出一个JAVA 语言版的求迷宫入口到出口的最短路径的程序。程序的大部分使用标准c语言编写，包括
输入和输出。唯一用到C++库的地方是使用STL了中的deque。迷宫的宽和高，迷宫矩阵，迷宫的入口和出口
等数据从文件读入。程序首先读入迷宫数据，然后更新迷宫矩阵，并求出迷宫入口和出口之间的最短路径，
并输出最短路径长度。

C++版本的在这里： http://blog.youkuaiyun.com/liangbch/article/details/7595177

开始时，迷宫矩阵的每一个元素是0或-1，0表示可走，-1表示是墙，走不通。对所有和迷宫入
口相通的方格，其值被改为其距迷宫入口的最近距离（比如：5*5的矩阵）

{ 0,  0,  0,  0,  0},    
{-1,  0, -1,  0, -1},    
{ 0,  0, -1, -1, -1},    
{ 0, -1,  0,  0,  0},    
{ 0,  0,  0, -1,  0},

2.算法

  迷宫的矩阵的每一方格可用 MazeNode表示，里面最重要的是三个数字(x,y,d)来表示，x,y表示这个方格的坐标，d表示这个方格距入口
的距离.

  1.首先，将入口的坐标(x,y,0),放入双端队列my_queue。
  2. 接下来重复以下的过程，直到队列为空：

    2.1.从队列头部取出一个MazeNode，三元组（x,y,d)
    2.2.从右，下，左，上四个方向搜索找最相邻的一个节点， ：

       如果是 -1的格子（就是墙），则跳过；如果这个方格不是入口点，则有3种情况
      case 1.
      新方格对应的矩阵元素是0，表明新的方格距迷宫入口的距离尚未标记。
   则将新方格对应的矩阵元素设置为d+1,同时将三元组(x,y,d+1)入队
      case 2：
      新方格的对应的矩阵元素的值>d+1,表明该新方格距迷宫入口的距离已经标记但不是最近的。
   则将新方格对应的矩阵元素设置为d+1,同时将三元组(x,y,d+1)入队  
     case 3:
     如果新的方格的对应的矩阵元素<= d+1，该位置距入口的距离已经标记，则不做处理

  3.检查出口对应的矩阵元素M[exit.x][exit.y]的值，如果为0，表示没有一条路径可走，否则打印出
    口距入口的距离。

全部的代码见下：

package algorithm;
import java.util.*;
public class MazeShow {
     public static class MazeNode {	
	/* 0 means it is not processed yet or it is entrance point
	 * >0 means the shortest distance from the entrance node  
	 */
	private int distance; 
	/*
	 * data: it is setup during initialization phase.
	 * -1: means this node is wall.
	 * 0: means it can be went through.
	 */
	private int data;
	private int row;
	private int column;
	boolean isStartPoint;
	boolean isExitPoint;
	
	public MazeNode(){
		distance=0;
		data=0;
		column=0;
		row=0;
		isStartPoint=false;
		isExitPoint=false;
	}
	public int getRow(){
		return row;
	}
	public int getColumn(){
		return column;
	}
	public void setRow(int row){
		this.row=row;
	}
	public void setColumn(int column){
		this.column=column;
	}
	public int getDistance(){
		return distance;
	}
	public void setData(int data){
		this.data=data;
	}	
	public void setDistance(int dis){
		distance=dis;
	}
	public int getData(){
		return data;
	}	
	public void setStartPoint(boolean value){
		isStartPoint=value;
	}
	public void setEndPoint(boolean value){
		isExitPoint=value;
	}
	public boolean getStartPoint(){
		return isStartPoint;
	}
	public boolean getEndPoint(){
		return isExitPoint;
	}
   }
    
	public static int getMazeShortestDistance(){	
	   int MAZE_WIDTH=5;
	    int MAZE_HEIGHT=5;
	    int distance=0;
	    MazeShow.MazeNode[][] mymaze=new MazeShow.MazeNode[MAZE_HEIGHT][MAZE_WIDTH];
	    for(int height=0;height<MAZE_HEIGHT;height++)
	      for(int width=0;width<MAZE_WIDTH;width++) {
	    	  //Java OBJ array must create new each obj element after TYPE[][] m=new TYPE[5]6];
	    	  mymaze[height][width]=new MazeShow.MazeNode();
	    	  mymaze[height][width].setRow(height);
	    	  mymaze[height][width].setColumn(width);
	      }
	    
	    //set up as(0,0) as entrance point 
	    
	    mymaze[0][0].setData(0);
	    mymaze[0][0].setDistance(0);
		
	    //set up as(MAZE_WIDTH-1,MAZE_HEIGHT-1) as exit point 
		
	    mymaze[MAZE_HEIGHT-1][MAZE_WIDTH-1].setData(0);
	    mymaze[MAZE_HEIGHT-1][MAZE_WIDTH-1].setDistance(0);
	    
	    //set maze as below which is wall
	    /*
	     *   
       { 0,  0,  0,  0,  0},    
       {-1,  0, -1,  0, -1},    
       { 0,  0, -1, -1, -1},    
       { 0, -1,  0,  0,  0},    
       { 0,  0,  0, -1,  0},
	     * 
	     */
	    mymaze[1][0].setData(-1);
	    
	    mymaze[3][1].setData(-1);
	    
	    mymaze[1][2].setData(-1);
	    mymaze[2][2].setData(-1);
	    
	    mymaze[2][3].setData(-1);
	    mymaze[4][3].setData(-1);
	    
	    mymaze[1][4].setData(-1);
	    mymaze[2][4].setData(-1);
	    
	    //process now
	    Queue<MazeShow.MazeNode> mazequeue = new LinkedList<MazeShow.MazeNode>();
	    
	    //push the entrance point as start point
	    
	    mazequeue.offer(mymaze[0][0]);
	    MazeShow.MazeNode pnode=null;
	    
	    int pcolumn=0;
		int prow=0;
		MazeShow.MazeNode currentNode=null;
		
	    while(!mazequeue.isEmpty()) {
	    	//get the FIFO node from queue;
	    	currentNode=null;
	    	pnode=mazequeue.poll();
	    	
	    	for(int turn=0;turn<4;turn++) {
	    	 switch(turn) {
	    	  case 0: //left
	    		  if(pnode.getColumn()>0) {
	    			 pcolumn=pnode.getColumn()-1;
	 	    		 prow=pnode.getRow();
	 	    		 currentNode=mymaze[prow][pcolumn];
	    		   }
	    		  else 
	    			  currentNode=null;  
	    		    break;
	    	 case 1: //down	    		 
	 	    	  if(pnode.getRow()<(MAZE_HEIGHT-1)) {
	 	    		// not the lowest node
	 	    		pcolumn=pnode.getColumn();
		 	    	prow=pnode.getRow()+1;
		 	    	currentNode=mymaze[prow][pcolumn];
	 	    	  }
	 	    	  else 
	    			  currentNode=null;  
	    		    break;
	    	 case 2: //right 
	 	    	 if(pnode.getColumn()<(MAZE_WIDTH-1)) {
	 	    		// not the most right node
	 	    		 pcolumn=pnode.getColumn()+1;
	 	    		 prow=pnode.getRow();
	 	    		 currentNode=mymaze[prow][pcolumn];
	 	    	  }
	 	    	 else 
	    			  currentNode=null;  
	    		   break;
	    	 case 3: //up
	 	    	  if(pnode.getRow()>0) {
	 	    		 pcolumn=pnode.getColumn();
	 	    		 prow=pnode.getRow()-1;
	 	    		 currentNode=mymaze[prow][pcolumn];
	 	    	  } else
	 	    		 currentNode=null;  
	    		    break;
	    		    
	    	 default:
	    		   System.out.println("error, shall not reach here");
	    		   return -1;
	    	 }	
	    	 
	    	 if(currentNode==null)
	    		 continue;
	    	 //skip the wall node
	    	  if(currentNode.getData()== -1)
	    		 continue;
	    	
	    	  distance=currentNode.getDistance();
	    	  if(distance==0 && (!currentNode.getStartPoint())){
	    			  //this is node not processed yet and it is not startpoint
	    		   currentNode.setDistance(pnode.getDistance()+1);
	    		   mazequeue.offer(currentNode);
	    	  } 
	    	  else { if(distance>(pnode.getDistance()+1)){
	    				  //update to make it shorted
	    			 currentNode.setDistance(pnode.getDistance()+1);
	  	    		 mazequeue.offer(currentNode);
	    		     } 
	    	        else { //if distance < (pnode.getDistance()+1
	    		    	    //nothing to do	    		    	 
	    		     }	    			  
	    		  }	    			  
	    		}
	    	}
	    
		return (distance= mymaze[MAZE_HEIGHT-1][MAZE_WIDTH-1].getDistance());
	}
}