Day23：代码随想录算法训练营第二十三天|回溯算法基础 1.力扣491 递增子序列 2.力扣46 全排列 3.力扣47 全排列2

力扣491 递增子序列

题目描述：
给定一个整型数组, 你的任务是找到所有该数组的递增子序列，递增子序列的长度至少是2。

示例:

输入: [4, 6, 7, 7]
输出: [[4, 6], [4, 7], [4, 6, 7], [4, 6, 7, 7], [6, 7], [6, 7, 7], [7,7], [4,7,7]]

说明:

1. 给定数组的长度不会超过15。
2. 数组中的整数范围是 [-100,100]。
3. 给定数组中可能包含重复数字，相等的数字应该被视为递增的一种情况。

思路：
这里难点主要是去重，因为要求是递增子序列，那么排序去重肯定是不行了。
那这里就采用了哈希表的方法，每一层定义一个哈希表存放for中读取到的数，如果后续的读到了前面存在过的，那么此时就可以continue跳过该元素，达到了同层相同元素不重复的作用。
又由于是没有限制长度，那么只要path的长度大于了1，那就要保存到结果集当中，且不需要return，因为当前的保存了，还需要继续向下保存，如果保存了就返回会丢失很多种情况，就类似于求定长的递增组合了。一定是要是每一层自己从for循环中跳出。

代码如下：

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& nums, int startIndex){
        if(path.size() > 1){
            result.push_back(path);
        }
        unordered_set<int> use;//每一层都重新定义一个set
        for(int i = startIndex; i < nums.size(); i++){
            if(!path.empty() && nums[i] < path.back() ||use.find(nums[i]) != use.end() ){
                continue;
        }
        use.insert(nums[i]);
        path.push_back(nums[i]);
        backtracking(nums, i + 1);
        path.pop_back();
        //set不需要回溯，因为每一层都重新有一个，一旦到下一层set就自动清空了
    }
    }
    vector<vector<int>> findSubsequences(vector<int>& nums) {
            result.clear();
            path.clear();
            backtracking(nums, 0);
            return result;
    }
};

力扣46 全排列

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

示例:

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

思路：
这道题和组合不太相同，因为排列是要保证path长度肯定是和nums的长度相同，然后就是每一个path里的元素顺序不同。

那就是从根节点出发，每一个分支都必须是n层，n等于nums的大小，那就不能有startIndex的说法了，必须每一个都是从0开始循环，然后用一个used数组控制出现的元素不选取，遇到没有出现的元素就放入到path里。

还有就是注意这里的used是一个函数中全局的变量，也就是在递归中一直是这个used，没有重新定义，因此，在回溯的时候也需要回溯used数组。

代码如下：

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

力扣47 全排列2

题目描述：
给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。

示例 1：

输入：nums = [1,1,2]
输出： [[1,1,2], [1,2,1], [2,1,1]]

示例 2：

输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

提示：

1 <= nums.length <= 8
-10 <= nums[i] <= 10

思路：
这道题和上一道题就多了一个数组中有重复元素，基本的搜索思路还是for循环从0开始，然后依赖于一个used数组来表示是否当前元素用过。另外再加一个去重操作，这里去重可以是和组合一样用同一树层的去重，也可以用同一树枝的去重，这里只针对于排列问题可以这么做。两种都要求先排序再操作。

针对树层的去重：

if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) {
    continue;
}

针对树枝的去重：
这不适用于组合问题，因为组合的i开始时startIndex，这样用树枝的去重的话，例如（1,1,2），那1,1这种情况就直接被忽略了。

那对于排列而言，它的每个分支的深度相同，也就是不会出现某一种情况被忽略，而且每一次的递归是在nums中找到没有使用过的元素放入，出现重复的情况和组合不同的是，比如1，1，2，我在第一个1分支会得到1,1,2，第二个分支1也上根据used判断的话也会取到1,1,2, 如果此时有针对树枝的去重，那么第一个分支1的1,1,2这种情况就会直接被舍去。

if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == true) {
    continue;
}

代码如下：

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking (vector<int>& nums, vector<bool>& used) {
        // 此时说明找到了一组
        if (path.size() == nums.size()) {
            result.push_back(path);
            return;
        }
        for (int i = 0; i < nums.size(); i++) {
            // used[i - 1] == true，说明同一树枝nums[i - 1]使用过
            // used[i - 1] == false，说明同一树层nums[i - 1]使用过
            // 如果同一树层nums[i - 1]使用过则直接跳过
            if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) {
                continue;
            }
            if (used[i] == false) {
                used[i] = true;
                path.push_back(nums[i]);
                backtracking(nums, used);
                path.pop_back();
                used[i] = false;
            }
        }
    }
public:
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        result.clear();
        path.clear();
        sort(nums.begin(), nums.end()); // 排序
        vector<bool> used(nums.size(), false);
        backtracking(nums, used);
        return result;
    }
};