代码随想录 10.20 || 回溯 LeetCode 491.递增子序列、46.全排列、47.全排列Ⅱ

491.递增子序列

        给你一个整数数组 nums，找出并返回所有该数组中不同的递增子序列，递增子序列中 至少有两个元素。你可以按 任意顺序 返回答案，数组中可能含有重复元素，如出现两个整数相等，也可视作递增序列的一种特殊情况。

        491.递增子序列 和求数组子集问题 78.子集 和 90.子集Ⅱ 的相同之处在于，都需要收集每个元素的信息和去除重复的元素；不同之处在于，集合具有无序性，所以我们可以对给定的整数数组进行排序，而子序列具有序列行，不能破坏原数组中元素的顺序，因此不能对数组进行排序。

class Solution {
private:
    void backtracking(vector<int> &nums, int startIndex, vector<int> &path, vector<vector<int>> &result) {
        if (path.size() > 1) {
            result.push_back(path);
        }

        int used[201] = {0};
        for (int i = startIndex; i < nums.size(); i++) {
            if ((path.size() > 0 && nums[i] < path.back()) || used[nums[i] + 100] == 1) continue;

            used[nums[i] + 100] = 1;
            path.push_back(nums[i]);
            backtracking(nums, i + 1, path, result);
            path.pop_back();
        }
    }

public:
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        vector<vector<int>> result; vector<int> path;
        result.clear(); path.clear();
        backtracking(nums, 0, path, result);
        return result;
    }
};

        代码和求子集问题类似，不同之处在于我们没有对 sums 排序，所以不能使用 used 标志数组的方式去重，这里使用哈希表（set和数组）都可以，数组快一些，将使用过的元素记录下，当遇到重复元素时，不执行重复分支。当子序列的长度大于等于 2 时，记录子序列信息。在循环中，判定 path 长度大于 0 时以及当前元素大于等于 path 中的最后一个元素时，记录其信息。

46.全排列

        给定一个不含重复数字的数组 nums，返回其所有可能的全排列。你可以 按任意顺序 返回答案。排列问题不要求顺序，求出所有可能的排列即可，可以对原数组进行排序，从而去重。

class Solution {
private:
    bool isSecond(const vector<int> &nums, int &number) {
        for (int i = 0; i < nums.size(); i++) {
            if (number == nums[i]) return true;
        }
        return false;
    }

    void backtracking(vector<int> &nums, vector<int> &path, vector<bool> &used, vector<vector<int>> &result) {
        if (path.size() == nums.size()) {
            result.push_back(path);
            return ;
        }

        for (int i = 0; i < nums.size(); i++) {
            if (used[i] == true) continue;
            // if (isSecond(path, nums[i])) continue;
            path.push_back(nums[i]);
            used[i] = true;
            backtracking(nums, path, used, result);
            used[i] = false;
            path.pop_back();
        }
    }
public:
    vector<vector<int>> permute(vector<int>& nums) {
        vector<vector<int>> result; vector<int> path;
        result.clear(); path.clear();
        vector<bool> used(nums.size(), false);
        backtracking(nums, path, used, result);
        return result;
    }
};

        这里实现了两种去重方式，used 标志数组 和 isSecond 函数，两种都可以判断当前元素是否重复。

47.全排列Ⅱ

        给定一个可包含重复数字的序列 nums，按任意顺序 返回所有不重复的全排列。和 46.全排列 不同之处在于，本题允许 nums 中存在重复数字，这需要我们在遍历的过程中去重，筛选掉重复的路径和重复使用的元素，注意这是两种不同的去重，重复的路径指的是在宽度维度上，已经使用过的元素，而重复使用的元素是指，在深度维度上，重复选定的元素。之前在组合问题中，我们会使用 startIndex，startIndex 本身去除重复元素的作用，但是也同时去除了 startIndex 之前的元素，与本题要求不符。在本题中，我们需要取到所有的元素。

class Solution {
private:
    void backtracking(vector<int> &nums, vector<int> &path, vector<bool> &used, vector<vector<int>> &result) {
        if (path.size() == nums.size()) {
            result.push_back(path);
            return ;
        }

        for (int i = 0; i < nums.size(); i++) {
            if (used[i] == true || i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) continue;
            path.push_back(nums[i]);
            used[i] = true;
            backtracking(nums, path, used, result);
            used[i] = false;
            path.pop_back();
        }
    }
public:
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        vector<vector<int>> result; vector<int> path;
        result.clear(); path.clear();
        vector<bool> used(nums.size(), false);
        sort(nums.begin(), nums.end());
        backtracking(nums, path, used, result);
        return result;
    }
};

        代码的大体思路和使用到 used 标志数组去重的任务类似，唯一不同之处在于，在 for 中的判定条件中，我们需要对重复使用的元素做出判断，如果当前的元素，已经使用过，说明往下的树杈都是无用的，这时候我们直接 continue 即可。