子集问题2 中等🌟🌟🌟

问题描述

原文链接:90. 子集 II

给你一个整数数组 nums ,其中可能包含重复元素,请你返回该数组所有可能的子集(幂集)。

解集不能包含重复的子集。返回的解集中,子集可以按任意顺序排列。

示例 1:

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

示例 2:

输入:nums = [0]
输出:[[],[0]]

提示:

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

代码实现

Java

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    List<Integer> temp = new ArrayList<>();
    public List<List<Integer>> subsetsWithDup(int[] nums) {
        Arrays.sort(nums);
        backTrace(nums, 0);
        return res;
    }

    void backTrace(int[] nums, int index){
        res.add(new ArrayList<>(temp));
        //
        for(int i = index; i < nums.length; i++){
            // 去掉重复子集
            if(i > index && nums[i] == nums[i-1]){
                continue;
            }
            // 从多个元素中选一个
            temp.add(nums[i]);
            // 递归
            backTrace(nums, i + 1);
            temp.remove(temp.size() - 1);
        }
    }
}

Python

class Solution(object):
    def subsetsWithDup(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        res = []
        temp = []
        nums.sort()
        self.backTrace(nums, 0, temp, res)
        return res

    def backTrace(self, nums, index, temp, res):
        res.append(list(temp))

        for i in range(index, len(nums)):
            # 去掉重复子集
            if i > index and nums[i] == nums[i - 1]:
                continue
            # 从多个元素中选一个
            temp.append(nums[i])
            # 递归
            self.backTrace(nums, i + 1, temp, res)
            temp.pop()

C++

class Solution {
public:
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        vector<vector<int>> res;
        vector<int> temp;
        sort(nums.begin(), nums.end());
        backTrace(nums, 0, temp, res);
        return res;
    }

    void backTrace(vector<int>& nums, int index, vector<int>& temp, vector<vector<int>>& res) {
        res.push_back(temp);

        for (int i = index; i < nums.size(); i++) {
            // 去掉重复子集
            if (i > index && nums[i] == nums[i - 1]) {
                continue;
            }
            // 从多个元素中选一个
            temp.push_back(nums[i]);
            // 递归
            backTrace(nums, i + 1, temp, res);
            temp.pop_back();
        }
    }
};

Go

func subsetsWithDup(nums []int) [][]int {
    res := [][]int{}
    temp := []int{}
    sort.Ints(nums)
    backTrace(nums, 0, &temp, &res)
    return res
}

func backTrace(nums []int, index int, temp *[]int, res *[][]int) {
    *res = append(*res, append([]int{}, *temp...))

    for i := index; i < len(nums); i++ {
        // 去掉重复子集
        if i > index && nums[i] == nums[i-1] {
            continue
        }
        // 从多个元素中选一个
        *temp = append(*temp, nums[i])
        // 递归
        backTrace(nums, i+1, temp, res)
        *temp = (*temp)[:len(*temp)-1]
    }
}

发表评论

后才能评论