491.非递减子序列

中等题

这个题给出的实例很有陷阱性，之前的题是通过排序来对于相同树层的元素去重，而本题是求非递减子序列，如果排序了那就已经是自增子序列了，达不到题目的要求。
看图

可以看出，对于一个集合[4,7]，如果之前选择了7，那么在后面的7就不必选择了，因为如果选择了前面的7之后，一定递归到了包含了选择后一个7产生的所有情况
比如[4,7,6,7,9]
选择前面的7则有[4,7,7,9] [4,7] [4,7,9] [4,7,7]
如果只是选择后面的 7则有情况[4,7] [4,7,9] 可以看出前面一定是包括了后面的情况的，所以我们同样需要对于同一树层选择的元素去重
同一父节点下的同层上使用过的元素就不能再使用了

需要注意的点，unordered_set uset; 是记录本层元素是否重复使用，新的一层uset都会重新定义（清空），所以要知道uset只负责本层！所以递归完之后不需要清除，因为代表已使用过

class Solution {
public:
    vector<vector<int>> res;
    vector<int> path;
    void backTracking(vector<int>& nums, int step) {
        if (path.size() >= 2) {
            res.push_back(path);
        }
        if (step >= nums.size()) {
            return;
        }
        unordered_set<int> uset;
        for (int i = step; i < nums.size(); i++) {
            if (uset.find(nums[i]) != uset.end())
                continue;
            if (path.size() > 0 && path[path.size() - 1] > nums[i])
                continue;
            uset.insert(nums[i]);
            path.push_back(nums[i]);
            backTracking(nums, i + 1);
            path.pop_back();
        }
    }
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        // sort(nums.begin(),nums.end());
        backTracking(nums, 0);
        return res;
    }
};

go代码

var (
	res  [][]int
	path []int
)

func backTracking(nums []int, step int) {
	if len(path) > 1 {
		p := make([]int, len(path))
		copy(p, path)
		res = append(res, p)
	}
	if step >= len(nums) {
		return
	}
	uset := make(map[int]bool)
	for i := step; i < len(nums); i++ {
		if uset[nums[i]] {
			continue
		}
		if len(path) > 0 && path[len(path)-1] > nums[i] {
			continue
		}
		uset[nums[i]] = true
		path = append(path, nums[i])
		backTracking(nums, i+1)
		path = path[:len(path)-1]
	}
}

func findSubsequences(nums []int) [][]int {
	res = [][]int{}
	path = []int{}
	backTracking(nums, 0)
	return res
}

46.全排列

模板题，不多说了,它不允许有重复元素出现
go代码

var (
	used []bool
	res  [][]int
	path []int
)

func backTracking(nums []int, used []bool) {
	if len(path) == len(nums) {
		temp := make([]int, len(path))
		copy(temp, path)
		res = append(res, temp)
		return
	}
	for i := 0; i < len(nums); i++ {
		if used[i] {
			continue
		}
		used[i] = true
		path = append(path, nums[i])
		backTracking(nums, used)
		used[i] = false
		path = path[:len(path)-1]
	}
}
func permute(nums []int) [][]int {
	used = make([]bool, len(nums))
	res = [][]int{}
	path = []int{}
	backTracking(nums, used)
	return res
}

47.全排列2

这道题和之前的区别就是，它允许有重复元素出现，这就会导致在同一树层中可能选取值相同的元素，所以需要去重，这道题可以排序用used数组，也可以定义uset集合，这里我定义了集合

class Solution {
public:
    vector<vector<int>> res;
    vector<int> path;
    void backTracking(vector<int>& nums, vector<bool>& used) {
        if (path.size() == nums.size()) {
            res.push_back(path);
            return;
        }
        unordered_set<int> uset;
        for (int i = 0; i < nums.size(); i++) {
            if (uset.find(nums[i]) != uset.end()) {
                continue;
            }
            if (used[i])
                continue;
            used[i] = true;
            uset.insert(nums[i]);
            path.push_back(nums[i]);
            backTracking(nums, used);
            used[i] = false;
            path.pop_back();
        }
    }
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        vector<bool> used(nums.size(), false);
        backTracking(nums, used);
        return res;
    }
};