代码随想录算法训练营Day28|491.递增子序列 ，46.全排列 ，47.全排列 II

今天的内容还是回溯的相关题目，来看第一道题目

491.递增子序列：代码随想录

这道题目的意思就是，给你一个整数数组nums，让你找出该数组中所有的不同的递增子序列，相等的也是可以的，然后子序列里至少含有两个元素，这道题我犯了一个错误，我一开始用了一个used数组来去除重复的元素，但是我忘记了使用数组来去重是要先将数组排序的，又因为他这个数组是有顺序要求的，所以不能排序，所以这题你不能使用used数组来进行去重，这题我们可以用unordered_set来去除重复元素，这里我们没有必要将unordered_set定义为全局变量，因为我们知道在每一次标记完之后，我们要进行回溯的操作，此时我们要将标记过已经访问过的元素，再重新标为未访问，但是在unordered_set中进行这个操作是有点麻烦的，所以我们干脆就将unordered_set定义在每一层的递归函数里面，你想想看，我们要做的是树层去重对吧，那树层去重的那一层是不是就是在同一层的函数里呢，因为我们递归函数的嵌套层数就是我们那颗递归树的深度嘛，所以我们只需要在递归函数里定义，在下一层中就会新开辟一个unordered_set，还会帮我们省去回溯的操作，这样岂不是一举两得。下面来看具体代码的实现：

class Solution {
public:
    vector<vector<int>> result;
	vector<int> ans;
	vector<vector<int>> findSubsequences(vector<int>& nums) {
		backtracking(0, nums);
		return result;
	}
	void backtracking(int index, vector<int>& nums) {
		if (ans.size() > 1) {
			result.push_back(ans);
		}
		set<int> uset;
		for (int i = index; i < nums.size(); i++) {
			if (ans.empty() == false && nums[i] < ans.back() || uset.find(nums[i]) != uset.end()) {
				continue;
			}
			else {
				ans.push_back(nums[i]);
				uset.insert(nums[i]);
				backtracking(i + 1, nums);
				ans.pop_back();
			}
		}
	}
};

当我们的ans结果中存在元素，并且我当前遍历的这个元素小于我ans中的最后一个元素时，代表不符合条件，直接continue跳过，还有就是在unordered_set中找到了该元素时，也要跳过，这就是本题的解答，来看下一道题。

46.全排列：代码随想录

这里可能会有不知道排列是啥意思的，你知道一点就行了，在组合中不允许出现1，2，2和2，2，1这两种组合，但是在排列中是允许的，也就是说两种情况的元素相同但是顺序不同的情况是允许在排列中出现的，那么知道这一点这题就很简单了，我们可以使用一个used数组来标记我们使用过哪些元素，然后再递归的去遍历那些没有标记过的元素，然后递归结束后，进行回溯就可以了，收集结果呢当然就是在ans里的元素个数等于nums的元素个数时就可以收集结果了，因为题目说的是全排列嘛，来看具体代码的实现：

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

来看下一道题目

47.全排列 II：代码随想录

这道题目其实和上一道题目一样，只不过是在nums数组中可能包含重复的元素，这也就是说我们要进行去重的操作了，那么我们如何进行去重的操作呢，当然是和前面一样用标记数组呢，为什么不用unordered_set呢，因为这里可以对数组进行排序啊，所以用标记数组来解决，这里加上前面的判断一个元素是否被使用过，就是有两个标记数组了，一起来看具体代码的实现

class Solution {
public:
    vector<vector<int>> result;
    vector<int> ans;
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        int n = nums.size();
        bool used[n]; bool flag[n];
        for (int i = 0; i < n; i++) {
            used[i] = true;
            flag[i] = true;
        }
        sort(nums.begin(),nums.end());
        backtracking(nums, used, flag);
        return result;
    }
    void backtracking(vector<int> nums, bool used[], bool flag[]) {
        if (ans.size() == nums.size()) {
            result.push_back(ans);
        }
        for (int i = 0; i < nums.size(); i++) {
            if(used[i]==false) continue;
            if (used[i] == true && i != 0 && nums[i - 1] == nums[i] && flag[i - 1] == true) {
                continue;
            }
            else if(used[i] == true && i != 0 && nums[i - 1] == nums[i] && flag[i - 1] == true) {
                ans.push_back(nums[i]);
                used[i] = false;
                flag[i]=false;
                backtracking(nums, used,flag);
                used[i] = true;
                flag[i]=true;
                ans.pop_back();
            }
            else{
                ans.push_back(nums[i]);
                used[i] = false;
                flag[i]=false;
                backtracking(nums, used,flag);
                used[i] = true;
                flag[i]=true;
                ans.pop_back();
            }
        }
    }
};

代码写的有点冗余，不过问题不大，直接来看单层递归的逻辑吧，当我的used数组为false时，代表已经取过该元素了，所以直接跳过，当该元素与前面一个元素相等并且是在同一颗树上时，就要进行去重，就直接continue，否则的话，就是加入到ans中然后进行回溯就可以了，以上就是今天的全部内容。