深度优先搜索

一、算法介绍

深度优先搜索是一种图的遍历算法，思想是从一个顶点开始，沿着一条路一直走到底，如果发现不能到达目标解，那就返回到上一个节点，然后从另一条路开始走到底，这种尽量往深处走的概念即是深度优先的概念。

二、应用

1.迷宫问题

问题描述：迷宫中的入口到迷宫中某一目标点的最短步数，移动方向只能是相邻的上下左右，而且不能越过障碍物。

解题思路：递归、深度优先搜索

java代码：

public class DFSMaze {

    //迷宫目标点的x坐标
    public static int endX = 3;
    
    //迷宫目标点的y坐标
    public static int endY = 2;
    
    //到达迷宫目标点的最小步数
    public static int minStep = 9999;
    
    //下一步的方向：右、下、左、上
    public static int[][] direct = {{0,1},{1,0},{0,-1},{-1,0}};
    
    //迷宫数组的边界（n行*m列）
    public static int n = 5;
    public static int m = 4;
    
    //标记位置是否走过，走过标1，没走0
    public static int[][] book = {
            {0,0,0,0},
            {0,0,0,0},
            {0,0,0,0},
            {0,0,0,0},
            {0,0,0,0}};
    
    //迷宫数组:0表示通道，1表示障碍物
    public static int[][] maze = {
            {0,0,1,0},
            {0,0,0,0},
            {0,0,1,0},
            {0,1,0,0},
            {0,0,0,1}};
    
    public static void main(String[] args){
        
        dfs(0,0,0);
        System.out.println(minStep);
    }
    
    //递归实现，深度优先搜索
    public static void dfs(int x,int y,int stepNum){
        
        //判断当前点是否是目标点
        if(x==endX && y==endY){
            if(stepNum < minStep){
                minStep = stepNum;
                return;
            }
        }
        
        //枚举4种走法
        int nextX;
        int nextY;
        for(int i=0;i<4;i++){
            nextX = x+direct[i][0];
            nextY = y+direct[i][1];
            //判断是否越界
            if(nextX<0||nextX>=n||nextY<0||nextY>=m){
                continue;
            }
            //判断是否障碍物，是否已经走过
            if(maze[nextX][nextY]==0 && book[nextX][nextY]==0){
                book[nextX][nextY] = 1;
                dfs(nextX,nextY,stepNum+1);
                book[nextX][nextY] = 0;
            }
        }
        return;
        
    }
}

2.全排列

问题描述：给定一个数字列表，返回其所有可能的排列。（你可以假设没有重复数字。）

样例：给出一个列表[1,2,3]，其全排列为：

[
  [1,2,3],
  [1,3,2],
  [2,1,3],
  [2,3,1],
  [3,1,2],
  [3,2,1]
]

java代码：（lintcode）

class Solution {
   
   int[] copyNums;
    /**
     * @param nums: A list of integers.
     * @return: A list of permutations.
     */
    public List<List<Integer>> permute(int[] nums) {
        // write your code here
        int numLen = nums.length;
        int book[] = new int[numLen];
        copyNums = new int[numLen];
        for(int i = 0 ; i <numLen ; i++){
            book[i] = 0;
        }
        for(int i = 0 ; i <numLen ; i++){
            copyNums[i] = nums[i];
        }
        
        List<List<Integer>> result = new ArrayList<>();
        dfs(0,nums,book,result);
        return result;
    }
    
    public void dfs(int step,int[] nums,int[] book,List<List<Integer>> result){
        
        if(step == nums.length){
            List<Integer> pl = new ArrayList<>();
            for(int i=0;i<nums.length;i++){
                pl.add(copyNums[i]);
            }
            result.add(pl);
            return;
        }
        for(int i=0;i<nums.length;i++){
            if(book[i]==0){
                copyNums[step] = nums[i];
                book[i] = 1;
                dfs(step+1,nums,book,result);
                book[i] = 0;
            }
            
        }
        return;
    }
}