力扣：全排列序列 (树层、树枝剪枝详解)

题目描述

---

给定一个 没有重复 数字的序列，返回其所有可能的全排列。
力扣：46. 全排列
力扣：面试题 08.07. 无重复字符串的排列组合

输入: [1,2,3]
输出:
[
[1,2,3],
[1,3,2],
[2,1,3],
[2,3,1],
[3,1,2],
[3,2,1]
]

排列问题，每次都需要从头开始搜索，因为 [ 1 , 2 ] 和 [ 2 , 1 ] 是两种排列情况，因此与 组合总和 、 子集问题 最大的不同就是 for 循环中不再是用 startIndex ，而是每次都需要从 原数组 0 开始遍历 ， 如果还是前两问题的做法，必然会导致大量的重复结果 。
这里就需要通过 used 数组进行剪枝， 「 记录此时 path 里都有哪些元素使用了，一个排列里一个元素只能使用一次 」

什么时候使用 used 数组，什么时候使用 startIndex 变量
参考大佬 liweiwei1494 的题解

• 排列问题，讲究顺序（即 [2, 2, 3] 与 [2, 3, 2] 视为不同列表时），需要记录哪些数字已经使用过，此时用 used 数组；
• 组合问题，不讲究顺序（即 [2, 2, 3] 与 [2, 3, 2] 视为相同列表时），需要按照某种顺序搜索，此时使用 startIndex 变量。
  注意：具体问题应该具体分析， 理解算法的设计思想 是至关重要的，请不要死记硬背。

class Solution {
    
    int[] nums;
    List<List<Integer>> result = new ArrayList<>();
   
    public List<List<Integer>> permute(int[] nums) {
        this.nums = nums;
        boolean[] used = new boolean[nums.length];
        List<Integer> path = new ArrayList<>();
        dfs(path , used , 0);
        return result;
    }
    
    public void dfs(List<Integer> path , boolean[] used , int depth){
        if(depth == nums.length){
            result.add(new ArrayList<>(path));
            return ;
        }
        for(int i = 0 ; i < nums.length ; i ++){
            if(!used[i]){
                path.add(nums[i]);
                used[i] = true;
                dfs(path , used , depth + 1);
                used[i] = false;
                path.remove(path.size() - 1);
            }
        }
    }
}

无重复字符串的排列组合 ： 和上面完全一样，只需要先将 String 转换为 char[] 数组 ， 以及最后的返回值处理一下即可 。后续的 有重复字符串的排列组合 也是同理 。

List<String> result = new ArrayList<>();
public String[] permutation(String S) {
     StringBuffer path = new StringBuffer("");
     char[] chars = S.toCharArray();
     boolean[] used = new boolean[chars.length]; // a - z A - Z
     backtracking(chars , path , used , 0);
     String[] strs = new String[result.size()];
     return result.toArray(strs); // 稍作处理
}

---

题目修改 ：
给定一个 可包含重复数字 的序列 nums ，按任意顺序 返回所有不重复的全排列。
力扣：47. 全排列 II
面试题 08.08. 有重复字符串的排列组合
就序列 nums 可包含重复数字 ，首先需要对 原数组排序 ，其次就是 添加合适剪枝 ，具体可参考 针对组合、子串问题总结

class Solution {
    List<List<Integer>> result = new ArrayList<>();
    public List<List<Integer>> permuteUnique(int[] nums) {
        List<Integer> path = new ArrayList<>();
        boolean[] used = new boolean[nums.length];
        Arrays.sort(nums);
        backtracking(path , used , nums , 0);
        return result;
    }

    public void backtracking(List<Integer> path , boolean[] used , int[] nums , int count){
        if(count == nums.length){
            result.add(new ArrayList<>(path));
            return ;
        }

        for(int i = 0 ; i < nums.length ; i ++){
            if(i > 0 && nums[i - 1] == nums[i] && used[i - 1] == false) continue; // 剪枝，避免重复的结果出现
            if(used[i] == true) continue; // 已经遍历过了
            used[i] = true;
            path.add(nums[i]);
            backtracking(path , used , nums , count + 1);
            path.remove(path.size() - 1);
            used[i] = false;
        }
    }
}

---

拓展 ：「 如果改成 used[ i - 1 ] == true， 也是正确的! 」
具体分析细节请 参考公众号：代码随想录 ，该公众号良心推荐，作者每道题都是利用 图解 ，思路清晰易懂 。
如果要对 树层中前一位去重，就用 used[i - 1] == false，如果要对 树枝前一位去重 用 used[i - 1] == true 。
「对于排列问题，树层上去重 和 树枝上去重，都是可以的，但是 树层上去重 效率更高！」
作者通过 [ 1 , 1 , 1 ] 举例 ， 分析了 树层 和 树枝 上去重 ， 的属性结构
(1)、树层上去重 used[i - 1] == false
(2) 、 树枝上去重 used[i - 1] == true
大家应该很清晰的看到，树层上对前一位去重非常彻底，效率很高，树枝上对前一位去重虽然最后可以得到答案，但是做了很多无用搜索。