Leetcode 46-全排列

题目描述

给定一个 没有重复 数字的序列，返回其所有可能的全排列。

示例:

题解

题解转载自liweiwei1419
深度优先搜索 算法（DFS）是一种用于遍历或搜索树或图的算法。这个算法会尽可能深 的搜索树的分支。当结点 v 的所在边都己被探寻过，搜索将 回溯 到发现结点 v 的那条边的起始结点。这一过程一直进行到已发现从源结点可达的所有结点为止。如果还存在未被发现的结点，则选择其中一个作为源结点并重复以上过程，整个进程反复进行直到所有结点都被访问为止。

从全排列问题开始理解回溯算法
我们尝试在纸上写 3 个数字的全排列，以数组 [1, 2, 3] 的全排列为例。

先写以 1 开头的全排列，它们是：[1, 2, 3], [1, 3, 2]，即 1 + [2, 3] 的全排列（注意：递归结构体现在这里）；
再写以 2 开头的全排列，它们是：[2, 1, 3], [2, 3, 1]，即 2 + [1, 3] 的全排列；
最后写以 3 开头的全排列，它们是：[3, 1, 2], [3, 2, 1]，即 3 + [1, 2] 的全排列。
总结搜索的方法：按顺序枚举每一位可能出现的情况，已经选择的数字在 当前 要选择的数字中不能出现。 按照这种策略搜索就能够做到 不重不漏。这样的思路，可以用一个树形结构表示。
「全排列」问题的树形结构。

说明：
每一个结点表示了求解全排列问题的不同的阶段，这些阶段通过变量的「不同的值」体现，这些变量的不同的值，称之为「状态」；
使用深度优先遍历有「回头」的过程，在「回头」以后， 状态变量需要设置成为和先前一样 ，因此在回到上一层结点的过程中，需要撤销上一次的选择， 这个操作称之为「状态重置」；
深度优先遍历，借助系统栈空间，保存所需要的状态变量，在编码中只需要注意遍历到相应的结点的时候，状态变量的值是正确的，具体的做法是：往下走一层的时候，path 变量在尾部追加，而往回走的时候，需要撤销上一次的选择，也是在尾部操作，因此 path 变量是一个栈；
深度优先遍历通过「回溯」操作，实现了全局使用一份状态变量的效果。
使用编程的方法得到全排列，就是在这样的一个树形结构中完成 遍历，从树的根结点到叶子结点形成的路径就是其中一个全排列。

设计状态变量

首先这棵树除了根结点和叶子结点以外，每一个结点做的事情其实是一样的，即：在已经选择了一些数的前提下，在剩下的还没有选择的数中，依次选择一个数，这显然是一个 递归 结构；
递归的终止条件是： 一个排列中的数字已经选够了 ，因此我们需要一个变量来表示当前程序递归到第几层，我们把这个变量叫做 depth
布尔数组 used，初始化的时候都为 false 表示这些数还没有被选择，当我们选定一个数的时候，就将这个数组的相应位置设置为 true ，这样在考虑下一个位置的时候，就能够以 O(1) 的时间复杂度判断这个数是否被选择过，这是一种「以空间换时间」的思想。
这些变量称为 「状态变量」 ，它们表示了在求解一个问题的时候所处的阶段。需要根据问题的场景设计合适的状态变量。

代码实现

class Solution {
    // 使用一个动态数组保存所有可能的全排列
    List<List<Integer>> res = new ArrayList<>();
    public List<List<Integer>> permute(int[] nums) {
        if(nums==null) return res;
        boolean[] used = new boolean[nums.length];
        List<Integer> path = new ArrayList<>();
        dfs(nums,0,nums.length,used,path);
        return res;

    }

    public void dfs(int[] nums,int depth,int len,boolean[] used,List<Integer> path){
        //递归终止条件：全排列中每一位都被选择
        if(depth==len){
            //变量 path 所指向的列表在深度优先遍历的过程中只有一份 ，深度优先遍历完成以后，回到了根结点，成为空列表。所以在添加到res时需要做一个拷贝
            res.add(new ArrayList<>(path));
            //返回
            return;
        }

        // 在非叶子结点处，产生不同的分支，这一操作的语义是：在还未选择的数中依次选择一个元素作为下一个位置的元素，这显然得通过一个循环实现。
        for(int i=0;i<len;i++){
            if(!used[i]){
                path.add(nums[i]);
                used[i]=true;
                
                //向下一层递归
                dfs(nums,depth+1,len,used,path);
    
                // 注意：下面这两行代码发生 「回溯」，回溯发生在从 深层结点 回到 浅层结点 的过程，代码在形式上和递归之前是对称的
                path.remove(path.size()-1);
                used[i]=false;
            }
        }
    }
}

参数简洁版本

 List<List<Integer>> res1 = new LinkedList<>();
    int len;
    boolean[] used;

    public List<List<Integer>> permute(int[] nums) {
        // 首先是特判
        len = nums.length;

        if (len == 0) {
            return res1;
        }

        used = new boolean[len];
        List<Integer> path = new ArrayList<>();

        dfs(nums, path);
        return res1;
    }

    private void dfs(int[] nums, List<Integer> path) {
        if (path.size() == len) {
            res1.add(new ArrayList<>(path));
            return;
        }

        for (int i = 0; i < len; i++) {
            if (!used[i]) {
                //决策树上进行选择
                path.add(nums[i]);
                used[i] = true;

                dfs(nums, path);
                //状态重置，撤销选择
                used[i] = false;
                //remove函数中的参数是index值
                path.remove(path.size() - 1);
            }
        }
    }

思路总结：

回溯算法的重点就是：
此刻的状态是什么(确定状态变量)
怎么前进（进入下一个状态）；
怎么回退（回到上一个状态）；
再加上搞明白什么时候停止。

• 按顺序枚举每一位可能出现的情况，已经选择的数字在 当前要选择的数字中不能出现。可以用一个树形结构表示该思路。
• 全排列就是在这样的一个树形结构中完成遍历，从树的根结点到叶子结点形成的路径就是其中一个全排列。
• 首先这棵树除了根结点和叶子结点以外 ，每一个结点做的事情其实是一样的 ，即：在已经选择了一些数的前提下，在剩下的还没有选择的数中，依次选择一个数，这显然是一个 递归结构 (遍历树节点选用递归来做)
  递归的终止条件是： 一个排列中的数字已经选够了 ，因此需要一个变量来表示当前程序递归到第几层，这个变量叫做 depth
  布尔数组 used，为 false 表示这些数还没有被选择，当选定一个数的时候，就将这个数组的相应位置设置为 true
• 使用深度优先遍历有「回头」的过程 ，因此在回到上一层结点的过程中，需要撤销上一次的选择，具体的做法是：往下走一层的时候，path 变量在尾部追加，used设置为true,而往回走的时候，需要撤销上一次的选择，也是在尾部操作，因此 path 变量是一个栈,且used要设置为false；