代码随想录算法训练营第25天｜leetcode-优快云博客

思路：如下

    vector<vector<int>> res;
    vector<int> path;
    void backtracking(vector<int> &nums, int start)
    {
        if (path.size() >= 2)
        {
            res.push_back(path);
        } // 注意这里不能加return，要取树上的节点
        unordered_set<int> used; // 用set对本层元素进行去重
        for (int i = start; i < nums.size(); i++)
        {
            if ((path.empty() || nums[i] >= path.back())&&(used.find(nums[i])==used.end()))
            //这个是同一层中不能出现相同元素，并不影响深度方向上的重复
            {
                used.insert(nums[i]); // used只负责本层
                path.push_back(nums[i]);
                backtracking(nums, i + 1);
                path.pop_back();
            }
            else
                continue;
        }
    }
    vector<vector<int>> findSubsequences(vector<int> &nums)
    {
        backtracking(nums, 0);
        return res;
    }

优化方法：使用数组替换哈希表

 int used[201] = {0}; // 这里使用数组来进行去重操作，题目说数值范围[-100, 100]

然后在下面的if判断变成：

 if ((path.empty() || nums[i] >= path.back())&&used[nums[i]+100]==0)

数组，set，map都可以做哈希表，而且数组干的活，map和set都能干，但如果数值范围小的话能用数组尽量用数组。

2.46. 全排列 - 力扣（LeetCode）

思路：

    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int> &nums, int *used)
    {
        if (path.size() == nums.size())
        {
            result.push_back(path);
            return;
        }
        for (int i = 0; i < nums.size(); i++)
        {
            if (used[nums[i] + 10])
            {
                continue;
            }
            path.push_back(nums[i]);
            used[nums[i]+10] = 1;
            backtracking(nums, used);
            used[nums[i]+10] = 0;
            path.pop_back();
        }
    }
    vector<vector<int>> permute(vector<int> &nums)
    {
        if (nums.size() == 0)
            return result;
        int used[21] = {0};
        backtracking(nums, used);
        return result;
    }

排列问题的不同：

每层都是从0开始搜索而不是startIndex
需要used数组记录path里都放了哪些元素了

3.47. 全排列 II - 力扣（LeetCode）

还要强调的是去重一定要对元素进行排序，这样我们才方便通过相邻的节点来判断是否重复使用了。

nums[i] == nums[i-1] 且 used[i-1]==1:说明同一树枝上有重复元素，可以重复选取
nums[i] == nums[i-1] 且 used[i-1]==0:说明同一树层上有重复元素，不可以重复选取

下面代码for里面的第一个if是树层去重，解释如上。第二个if因为path里已经收集那个元素了，直接跳过

    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;
        }
        for (int i = 0; i < nums.size(); i++)
        {
            if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) // 树层去重
                continue;//树层去重
            if (used[i] == true)
                continue;//path里已经收录的元素，直接跳过
            else
            {
                path.push_back(nums[i]);
                used[i] = true;
                backtracking(nums, used);
                used[i] = false;
                path.pop_back();
            }
        }
    }
    vector<vector<int>> permuteUnique(vector<int> &nums)
    {
        if (nums.size() == 0)
            return res;
        sort(nums.begin(), nums.end());
        vector<bool> used(nums.size(), false);
        backtracking(nums, used);
        return res;
    }

对于树枝去重和树层去重的深度理解：

A.树层去重：

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

B.树枝去重：

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

对于排列问题，树层上去重和树枝上去重，都是可以的，但是树层上去重效率更高！

A.树层去重：

B.树枝去重：