对于计算机，面对错乱复杂的迷宫探路问题也不可能一步就找到最优路径，而是把所有可行路径全部走过然后通过比较找出最优路径，对于每走一步都有4个可行方向可走，然后通过循环借助计算机的高效率找出最优路径。代码如下：

public class Maze {
//出口目标点坐标
private static final int X = 8;
private static final int Y = 8;

private static final int MaxSize = 200;
//迷宫路径
int[][] maze = {
{1,1,1,1,1,1,1,1,1,1},
{1,0,0,1,0,0,0,1,0,1},
{1,0,0,1,0,0,0,1,0,1},
{1,0,0,0,0,1,1,0,0,1},
{1,0,1,1,1,0,0,0,0,1},
{1,0,0,0,1,0,0,0,0,1},
{1,0,1,0,0,0,1,0,0,1},
{1,0,1,1,1,0,1,1,0,1},
{1,1,0,0,0,0,0,0,0,1},
{1,1,1,1,1,1,1,1,1,1},
};

Node Stack[] = new Node[MaxSize];
Node Path[] = new Node[MaxSize];
//栈顶指针
int top = -1;
//路径的计数
int count = 1;
//记录最短路径
int minlen = MaxSize;

public Maze() {
System.out.println(“路径如下：”);
mazePath(1,1,X,Y);
}
//寻路方法
public void mazePath(int xi,int yi,int xe,int ye){
int i,j,di,find;
//初始化栈 起始地点入栈
top++;
Node n = new Node();
Stack[top] = n;
System.out.println(Stack[top]);
Stack[top].i = xi;
Stack[top].j = yi;
Stack[top].di = -1;
maze[xi][yi] = -1;
//如果栈不为空就继续探路
while(top>-1){
//取出栈顶元素
i = Stack[top].i;
j = Stack[top].j;
di = Stack[top].di;
//判断是否已经找到目标点出口  如果找到出口那么打印路径
if(i==xe && j ==ye){
System.out.println(”  “+(count++));
for(int k = 0;k <= top;k++){
System.out.printf(“(%d , %d)”,Stack[k].i,Stack[k].j);
//每行打印5个坐标点然后换行
if((k+1)%5==0){
System.out.println(“”);
}
}
System.out.println(“”);
//找出最短路径  然后赋值给Path
if(top+1 < minlen){
minlen = top+1;
System.out.println(minlen+””);
for(int k = 0;k <= top;k++){
Node node = new Node();
Path[k] = node;
Path[k].i = Stack[k].i;
Path[k].j = Stack[k].j;
Path[k].di = Stack[k].di;
}
}
//退出一步继续查找可行路径
maze[Stack[top].i][Stack[top].j] = 0;
top–;
i = Stack[top].i;
j = Stack[top].j;
di = Stack[top].di;
}
//根据四个方向试探性的查找可行路径
find = 0;//用来标记是否已经找到可行路径  0 没找到  1找到
while(find==0 && di<4){
di++;
switch(di){
           case 0: i = Stack[top].i-1;j = Stack[top].j;break;
           case 1: i = Stack[top].i;j = Stack[top].j+1;break;
           case 2: i = Stack[top].i+1;j = Stack[top].j;break;
           case 3: i = Stack[top].i;j = Stack[top].j-1;break;
           }
//如果找到可行路径那么find标记为1
if(maze[i][j] == 0){
find = 1;
}
}
if(find == 1){
//如果找到出口那么进栈
Stack[top].di = di;  //进栈前记录当前立脚点的寻路方向
top++;
Node n1 = new Node();
Stack[top] = n1;
Stack[top].i = i;
Stack[top].j = j;
Stack[top].di = -1;
//已走过路径标记为-1防止重复路过
maze[i][j] = -1;
}else{
//否则退一步，然后继续试探可行路径
maze[Stack[top].i][Stack[top].j] = 0;  //释放路径 为了以后的试探让路
top–;
}
}
//一切执行结束后打印最短路径
System.out.println(“最短路径如下：”);
System.out.println(“最短路径长度：”+minlen);
System.out.println(“路径：”);
//打印最短路径
for(int k = 0;k < minlen;k++){
System.out.printf(“(%d , %d)”,Path[k].i,Path[k].j);
if((k+1)%5 == 0){
System.out.println(“”);
}
}
System.out.println(“”);
}
class Node{
int i;
int j;
int di;
}
public static void main(String[] args) {
new Maze();
}
}