【算法总结】——排列型回溯

排列型回溯

相比于组合，排列型回溯对于元素的顺序是有要求的。

为了在回溯的过程中 告诉之后还可以选择哪些数字，需要进行一些额外的记录，可以：

1. 记录已经被选择的数字
2. 用一个集合存储还可以被选择的数字

---

对于排列型回溯，（与其他类型回溯的主要区别就在于 需要额外的记录）

例题1——46. 全排列

https://leetcode.cn/problems/permutations/

依次尝试各个位置上放置哪个数字，同时记录哪些数字是已经被放置过了的。

class Solution {
    List<List<Integer>> ans = new ArrayList();
    List<Integer> t = new LinkedList();

    public List<List<Integer>> permute(int[] nums) {
        int n = nums.length;
        boolean[] st = new boolean[n];  // 记录第i个数是否已经被选过
        dfs(nums, st, 0);   // 第0个位置放置哪个数字
        return ans;
    }

    public void dfs(int[] nums, boolean[] st, int k) {
        if (k == nums.length) {
            ans.add(new ArrayList(t));
            return;
        }
        for (int i = 0; i < nums.length; ++i) { // 依次尝试各个数字放在第k个位置
            if (st[i]) continue;
            st[i] = true;
            t.add(nums[i]);
            dfs(nums, st, k + 1);
            st[i] = false;	// 恢复现场
            t.remove(t.size() - 1);
        }
    }
}

除了额外声明一个 st数组 来记录每个数字的状态之外，还可以通过给 nums数组 中已经被选择的数字加上一个特别大的数字，这样如果一个数字超过了原本数据的范围，那么就表示它已经被选择过了。

这道题目的时间复杂度的详细算法见本文的 # 分析回溯时间复杂度的另一种技巧 部分。

补充例题——全排列Ⅱ（需要去重的全排列）

47. 全排列 II

这道题目与普通全排列唯一的区别在于 需要去重。

去重方式1——排序+判断

class Solution {
    List<List<Integer>> ans = new ArrayList();
    List<Integer> t = new ArrayList();

    public List<List<Integer>> permuteUnique(int[] nums) {
        int n = nums.length;
        boolean[] used = new boolean[n];
        Arrays.sort(nums);	// 需要排序让相同的数字放在一起
        dfs(0, nums, used);
        return ans;
    }

    public void dfs(int curIdx, int[] nums, boolean[] used) {
        if (curIdx == nums.length) {
            ans.add(new ArrayList(t));
            return;
        }
        for (int i = 0; i < nums.length; ++i) {
            if (used[i] || (i > 0 && nums[i] == nums[i - 1] && !used[i - 1])) continue;	// 去重
            used[i] = true;
            t.add(nums[i]);
            dfs(curIdx + 1, nums, used);
            used[i] = false;
            t.remove(t.size() - 1);
        }
    }
}

去重方式2——树层used数组

class Solution {
    List<List<Integer>> ans = new ArrayList();
    List<Integer> t = new ArrayList();

    public List<List<Integer>> permuteUnique(int[] nums) {
        int n = nums.length;
        boolean[] used = new boolean[n];
        dfs(0, nums, used);
        return ans;
    }

    public void dfs(int curIdx, int[] nums, boolean[] used1) {
        if (curIdx == nums.length) {
            ans.add(new ArrayList(t));
            return;
        }
        boolean[] used2 = new boolean[21];		// 用于树层去重的used数组
        for (int i = 0; i < nums.length; ++i) {
            if (used1[i] || used2[nums[i] + 10]) continue;
            used2[nums[i] + 10] = true;
            used1[i] = true;
            t.add(nums[i]);
            dfs(curIdx + 1, nums, used1);
            used1[i] = false;
            t.remove(t.size() - 1);
        }
    }
}

例题2——N皇后

https://leetcode.cn/problems/n-queens/

思路：搜索每一行，尝试每一行的各个列是否可以放置棋子。（需要记录已经放置的情况来判断当前位置的合理性）

class Solution {
    char[][] borad;
    Set<Integer> s1 = new HashSet(), s2 = new HashSet(), s3 = new HashSet();
    List<List<String>> ans = new ArrayList();

    public List<List<String>> solveNQueens(int n) {
        borad = new char[n][n];
        for (int i = 0; i < n; ++i) Arrays.fill(borad[i], '.');
        dfs(0, n);
        return ans;
    }   

    public void dfs(int row, int n) {
        if (row == n) {
            List<String> t = new ArrayList();
            for (char[] line: borad) t.add(new String(line));
            ans.add(t);
            return;
        }
        for (int i = 0; i < n; ++i) {   // 遍历这一行的每一列
            if (!s1.contains(i) && !s2.contains(i + row) && !s3.contains(i - row)) {
                s1.add(i);
                s2.add(i + row);
                s3.add(i - row);
                borad[row][i] = 'Q';
                dfs(row + 1, n);	// 尝试下一行
                borad[row][i] = '.';
                s1.remove(i);
                s2.remove(i + row);
                s3.remove(i - row);
            }
        }
    }
}

同一 正斜线 和 反斜线 上的横纵坐标，他们的横纵坐标之和和之差分别是相同的。

除了使用 HashSet 来记录已经放置的情况外，还可以是用 boolean数组 来做记录。

这道题目的时间复杂度是 O(N^2 * N!)

分析回溯时间复杂度的另一种技巧

上次说过，时间复杂度就是 叶子节点的个数 乘上 根到叶子的路径长度，

对于 46. 全排列 来说，有 n! 个叶子节点（= $A_n^n$ = n!），而每条路径的长度是 n ，因此时间复杂度是 O(n*n!)

对应于组合型回溯，组合数$C_n^k$，时间复杂度就是 k * C(n, k)

---

但是！在计算每条路径的长度时，会有节点被重复计算，因此上面的时间复杂度算法并不精确（比如根节点，在计算每次路径长度时都被参与了运算）。

Q：如何直接计算这棵树有多少个节点？（精确，知道了节点的个数，也就知道了递归的次数）

每一层的节点分别是从 n 个数中选 k 个数的排列，
因此 节点个数：最后为 e * n!

---

但是！ 在 大O 下的时间复杂度其实不需要那么精确，
因此 力扣官方题解下的时间复杂度是这样的：

（是用放缩来做的）

---

最后附上 三种枚举（回溯）方式的一般时间复杂度考虑方式