33.矩阵中的路径（经典：递归+回溯）

我的思路分析:我知道和“迷宫回溯问题相类似”，但是我就是写不出来！！！！

注意：


这两句是一定会捆绑在一起使用的,有借有还(深度递归的时候就是在入栈操作，回溯的过程就是在按顺序出栈)

class Solution {
    public boolean exist(char[][] board, String word) {
        //遍历数组的每个元素来找到word的第一个字符
        for(int i=0;i<board.length;i++){
            for(int j=0;j<board[0].length;j++){
                if(findway(board,word,i,j,0)){
                    
                    return true;//有一条路径成功
                }

            //换个点(还是word的第一个字符)寻找下一条路径

            }
        }

        //一条路径也没找到，直接返回false
        return false;
    }



    public boolean findway(char[][] board,String word,int i,int j,int n){

        //上下左右有堵墙的情况，以及数组越界了的情况,或者直接不匹配
        if(i<0 || i>=board.length || j<0 || j>=board[0].length || board[i][j]!=word.charAt(n)){
            return false;//直接寻别路吧
        }

        if(n==word.length()-1){
            return true;//找到了完整的一条路
        }

        //当前board[i][j]==word.charAt(n)满足了(标志已经匹配的数组位置，防止重复使用)
        board[i][j]='\0';


        //往相邻的点继续递归
        boolean res=findway(board,word,i-1,j,n+1) ||findway(board,word,i+1,j,n+1) || 
                    findway(board,word,i,j-1,n+1) ||findway(board,word,i,j+1,n+1) ; 

        //开始回溯，递归结束---或者说一层层返回到上层后开始往下执行
        //恢复原来的样子(如果这条路不行的一个个原路返回，恢复原来的样子，并返回false)
        board[i][j]=word.charAt(n);

        return res;

    }
}

迷宫回溯问题代码：

    /**
     * @param: map表示原始的迷宫（下右上左策略）
     * @return:设置数组为1表示墙壁，设置数组值为2表示此路已经走通，为0表示未走过（表示：），为3表示走不通(走不通需要回溯)
     */
    public static boolean setway(int[][] map, int i, int j) {
        if (map[6][5] == 2) {
            return true;
        } else {
            //这条路没有尝试过，进行下右上左尝试，再判断是通路2还是死路3
            if (map[i][j] == 0) {
                map[i][j] = 2;//表示或许是可以通的路（如果下右上左均不通的话，说明此路是死路），暂时的置位2
                if (setway(map, i + 1, j)) {//向下
                    return true;
                } else if (setway(map, i, j + 1)) {//向右
                    return true;
                } else if (setway(map, i - 1, j)) {//向上
                    return true;
                } else if (setway(map, i, j - 1)) {//向左
                    return true;
                } else {
                    map[i][j] = 3;//说明此路不通（死路），设置为3，此时需要回溯（特指将上面打算至2的，给写为3，然后寻找别的方向）
                    return false;
                }


            } else {
             //map[i][j]不为0，为1,2,3，说明这条路不用再试了:1：墙壁；2：这条暂时通路已经试验过；3：下右上左均不行）
                return false;
            }
        }

    }

public class Migong {
    public static void main(String[] args) {
        //初始化迷宫，设置map[6][5]为出口
        int[][] map = new int[8][7];
        //设置第0行和第7行的置位1
        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;
//        map[1][2]=1;
        map[2][2] = 1;
        
        
        System.out.println("原始的迷宫：");
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 7; j++) {
                System.out.print(map[i][j] + " ");

            }
            System.out.println();
        }

        System.out.println("迷宫找路后：");

        //setway2(map, 1, 1);//上右下左策略
        setway(map, 1, 1);//下右上左策略
        
        
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 7; j++) {
                System.out.print(map[i][j] + " ");

            }
            System.out.println();

        }

    }