代码随想录算法训练营第二十五天|leetcode46、47、491题

一、leetcode第491题

using namespace std;

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;

    // 回溯函数用于找到递增子序列
    void backtracking(vector<int>& nums, int startIndex) {
        // 如果当前子序列长度大于1，则将其加入结果集
        if (path.size() > 1) {
            result.push_back(path);
            // 注意：这里不要直接返回，以便继续探索搜索树上的节点
        }

        // 使用集合来避免当前层级中的重复元素
        unordered_set<int> uset;

        // 从起始索引开始遍历剩余元素
        for (int i = startIndex; i < nums.size(); i++) {
            // 如果当前数字小于子序列中的最后一个数字，或者在当前层级中已经使用过，跳过
            if ((!path.empty() && nums[i] < path.back()) || uset.find(nums[i]) != uset.end()) {
                continue;
            }

            // 记录当前数字在当前层级中已经被使用
            uset.insert(nums[i]);

            // 将当前数字加入子序列
            path.push_back(nums[i]);

            // 递归调用回溯函数，继续探索
            backtracking(nums, i + 1);

            // 回溯，移除最后添加的数字
            path.pop_back();
        }
    }

public:
    // 函数用于在给定向量中找到所有递增子序列
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        result.clear();
        path.clear();
        backtracking(nums, 0);
        return result;
    }
};

二、leetcode第46题

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]) continue;

            // 标记当前元素为已使用
            used[i] = true;

            // 将当前元素加入排列路径中
            path.push_back(nums[i]);

            // 递归调用回溯函数，继续生成排列
            backtracking(nums, used);

            // 回溯，撤销当前元素的使用状态，并移出排列路径中的最后一个元素
            used[i] = false;
            path.pop_back();
        }
    }

    // 主函数，用于生成给定整数数组的所有排列
    vector<vector<int>> permute(vector<int>& nums) {
        result.clear(); // 清空结果集
        path.clear(); // 清空当前排列路径
        vector<bool> used(nums.size(), false); // 标记数组中每个元素的使用状态，默认为未使用
        backtracking(nums, used); // 调用回溯函数生成排列
        return result; // 返回所有排列的结果
    }
};

三、leetcode第47题

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++) {
            // 如果同一树层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);

                // 回溯，撤销当前元素的使用状态，并移出排列路径中的最后一个元素
                used[i] = false;
                path.pop_back();
            }
        }
    }

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; // 返回所有排列的结果
    }
};