走迷宫问题。

 要求：从左上角避开障碍，到达右下角通过。

 

思路：利用数组和递归实现。迷宫以二维数组实现，规定数组的值，障碍为1，路为0。 

for(int i=0;i<7;i++){
    map[0][i]=1;
    map[7][i]=1;
}
for(int i=0;i<8;i++){
    map[i][0]=1;
    map[i][6]=1;
}
map[3][1]=1;
map[3][2]=1;

 关键在于如何正确找到路径。

首先进一步规定数组值的意义。

规定数组元素值，0表示路，1表示障碍物，2表示可以走，3表示走过但走不通，即死路

从起点开始，任意方向都可以走，我们规定找路策略，按照下-右-上-左的顺序找路径。

此处利用递归回溯的思想。

public boolean findWay(int[][] map,int i,int j){
    if(map[6][5]==2){
        //说明已经找到
        return true;
    }else{
        if(map[i][j]==0){
            //说明可以走
            //假设可以走通
            map[i][j]=2;
            //使用找路策略，确定该位置是否真的可以走通
            //按下->右->上->左的顺序找
            if(findWay(map,i+1,j)){
                //先走下
                return true;
            }else if(findWay(map,i,j+1)){
                //先走右
                return true;
            }else if(findWay(map,i-1,j)){
                //先走上
                return true;
            }else if(findWay(map,i,j-1)){
                //先走左
                return true;
            }else{
                map[i][j]=3;
                return false;
            }

        }else{
            //map[i][j]=1,2,3
            return false;
        }
    }

 那么，换不同的策略寻找路径会产生不同的路径。这又产生了另一个问题，即如何寻找最短路径。1可以使用穷举，但此方法需要4*3*2=24种方法太繁琐。2利用图求。（后续补充）

代码：

public class Migong {
    public static void main(String[] args){
        //思路
        //1.先创建迷宫，用二维数组表示
        //2.规定数组元素值，0表示路，1表示障碍物
        int [][] map=new int[8][7];
        //3.利用数组设置地图
        for(int i=0;i<7;i++){
            map[0][i]=1;
            map[7][i]=1;
        }
        for(int i=0;i<8;i++){
            map[i][0]=1;
            map[i][6]=1;
        }
        map[3][1]=1;
        map[3][2]=1;
        //输出当前的地图
        System.out.println("===当前地图情况===");
        for(int i=0;i<map.length;i++){
            for(int j=0;j<map[i].length;j++){
                System.out.print(map[i][j]+" ");
                //输出一行
            }
            System.out.println();
        }
        T t1=new T();
        t1.findWay(map,1,1);
        //引用传递（影响main中数组的值）
        System.out.println("===找路后的情况如下===");
        for(int i=0;i<map.length;i++){
            for(int j=0;j<map[i].length;j++){
                System.out.print(map[i][j]+" ");
                //输出一行
            }
            System.out.println();
        }
    }
}
class T{
    //使用递归回溯的思想来解决老鼠出迷宫
    //findWay方法找路径，初始化位置（1,1）
    //规定数组元素值，0表示路，1表示障碍物，2表示可以走，3表示走过但走不通，即死路
    //当map[6][5]=2说明找到通路，结束。否则继续找
    //先规定找路策略，下->右->上->左
    public boolean findWay(int[][] map,int i,int j){
        if(map[6][5]==2){
            //说明已经找到
            return true;
        }else{
            if(map[i][j]==0){
                //说明可以走
                //假设可以走通
                map[i][j]=2;
                //使用找路策略，确定该位置是否真的可以走通
                //按下->右->上->左的顺序找
                if(findWay(map,i+1,j)){
                    //先走下
                    return true;
                }else if(findWay(map,i,j+1)){
                    //先走右
                    return true;
                }else if(findWay(map,i-1,j)){
                    //先走上
                    return true;
                }else if(findWay(map,i,j-1)){
                    //先走左
                    return true;
                }else{
                    map[i][j]=3;
                    return false;
                }

            }else{
                //map[i][j]=1,2,3
                return false;
            }
        }
        //换一种策略，按上->右->下->左，观察有什么变化
        /*if(map[6][5]==2){
            //说明已经找到
            return true;
        }else{
            if(map[i][j]==0){
                //说明可以走
                //假设可以走通
                map[i][j]=2;
                //使用找路策略，确定该位置是否真的可以走通
                //按上->右->下->左的顺序找
                if(findWay(map,i-1,j)){
                    //先走上
                    return true;
                }else if(findWay(map,i,j+1)){
                    //先走右
                    return true;
                }else if(findWay(map,i+1,j)){
                    //先走下
                    return true;
                }else if(findWay(map,i,j-1)){
                    //先走左
                    return true;
                }else{
                    map[i][j]=3;
                    return false;
                }

            }else{
                //map[i][j]=1,2,3
                return false;
            }
        }*/

    }
 }