深度优先搜索搜索对处理最短路径和找到一个可行路径的深思

引出题目：

从起点（0，0）出发，到达P点的一条可行路径和最短路径的步数 【" * "表示可走，"X"表示不可走，"P"表示终点】

                {'*','*','*','*','*','*','*','*'},
                {'X','X','X','X','X','X','*','*'},
                {'*','*','*','*','X','*','*','*'},
                {'*','*','X','*','X','*','X','X'},
                {'*','*','X','*','X','*','*','P'}
        

我们这里使用深度优先搜索算法（dfs），对于每一个坐标，都有四个方向可以移动，因此我们可以用一个二维数组来表示方向，再for循环遍历该数组来实现穷举一个坐标的每四个方向！！！
当前的元素坐标向下向上向左向右的四种情况

static int[][] dic = {{1,0},{-1,0},{0,1},{0,-1}};

我们发现对于每一个点上下左右会导致和其他点的上下左右导致重复的步骤！！因此我们还需要创建一个visited二维数组来映射判断对应坐标是否被访问，

boolean[][] visited=new boolean[row][col];

对于为了方便起见，我们使用返回值位boolean类型的函数来为我们实现，到找到了终点以后，我们就需要return当前函数，而且我们还需要return掉当前函数栈中其他寻找路径的函数！！（因为题目要求我们只是需要找到一条可行解即可），因此我们的代码需要这样写

boolean func(){
    if(way[x][y]=='P'){
    	return true;
	}
	……………【其他业务代码】
    if(find_way(way,a,b,visited)){
        return true;
    }
}

上面代码表示，假如我们找到了这个解（返回true），那么之后的代码也需要return，即不需要再找下去了！

1.到达P点的一条可行路径完整代码如下

    static int[][] dic = {{1,0},{-1,0},{0,1},{0,-1}};
    public static void find_way(char[][] way,int x,int y){
        int row = way.length;
        int col = way[0].length;
        boolean[][] visited=new boolean[row][col];
        find_way(way,x,y,visited);
    }
    private static boolean find_way(char[][] way,int x,int y,boolean[][] visited){
        if(way[x][y]=='P'){
            return true;
        }
        else if(way[x][y]=='X'){
            return false;
        }
        way[x][y] = 'D';
        visited[x][y] = true;
        for (int[] ints : dic) {
            int a = x+ints[0];
            int b = y+ints[1];
            if(a<0 || a>=visited.length || b<0 || b>=visited[0].length){
                continue;
            }
            if(visited[a][b]){
                continue;
            }
            if(find_way(way,a,b,visited)){
                return true;
            }
        }
        //四个方向都找不到，需要撤回
        way[x][y] = '*';
        visited[x][y] = false;
        return false;
    }

这里也提供了void返回值函数的代码

题目二（找最短路径的步数）

对于上面的逻辑之后，这里的思路就变得更加清晰了，因为上面是需要找一条，即对于找到一个答案之后的栈函数的处理逻辑是直接return掉，我们这里需要穷举出所有的路径，因此我们对找到一个答案之后的逻辑不再是return处理，而是继续让它去寻找，再找到语句中不断更新最小步数depth即可！！
因此代码如下

    static int[][] dic = {{1,0},{-1,0},{0,1},{0,-1}};
    static int max = Integer.MAX_VALUE;
    public static void find_way(char[][] way,int x,int y){
        int row = way.length;
        int col = way[0].length;
        boolean[][] visited=new boolean[row][col];
        find_way(way,x,y,visited,0);
    }
    private static void find_way(char[][] way,int x,int y,boolean[][] visited,int depth){
        if(way[x][y]=='P'){
            max = Math.min(max, depth);
            return ;
        }
        if(way[x][y]=='X'){
            return;
        }
        way[x][y] = 'D';
        visited[x][y] = true;
        for (int[] ints : dic) {
            int a = x+ints[0];
            int b = y+ints[1];
            if(a<0 || a>=visited.length || b<0 || b>=visited[0].length){
                continue;
            }
            if(visited[a][b]){
                continue;
            }
            find_way(way,a,b,visited,depth+1);
        }
        //无论找不找的到，都需要将原来的值重置
        visited[x][y] = false; //供其他需要找的函数重新使用该区域，因为有可能找到更短的路径
    }

这里需要注意一点就是visited[x][y]=false 需要重新置为 false