[Swift]LeetCode90. 子集 II | Subsets II

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/9936308.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

Given a collection of integers that might contain duplicates, nums, return all possible subsets (the power set).

Note: The solution set must not contain duplicate subsets.

Example:

Input: [1,2,2]
Output:
[
  [2],
  [1],
  [1,2,2],
  [2,2],
  [1,2],
  []
]

---

给定一个可能包含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。

说明：解集不能包含重复的子集。

示例:

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

---

12ms

class Solution {
    func subsetsWithDup(_ nums: [Int]) -> [[Int]] {
        
        var result = [[Int]]()
        var temp = [Int]()
        
        var sortedNums = nums.sorted()
        
        backTrack(sortedNums, &result, &temp, 0)
        return result
    }
    
    func backTrack(_ nums: [Int], _ result: inout [[Int]], _ temp: inout [Int], _ start: Int) {
        guard start <= nums.count else {return}
        result.append(temp)
        for i in start ..< nums.count {
            if i > start && nums[i] == nums[i - 1] {continue}
            temp.append(nums[i])
            backTrack(nums, &result, &temp, i + 1)
            temp.removeLast()
        }
    }
}

---

12ms

class Solution {
    func subsetsWithDup(_ nums: [Int]) -> [[Int]] {
        
        let nums = nums.sorted()
        var result: [[Int]] = [[]]
        
        var index = 0
        
        while index < nums.count {
            print(index)
            
            var dupCount = 0
            
            for dupIndex in index..<nums.count {
                if nums[dupIndex] == nums[index] {
                    dupCount += 1
                } else {
                    break
                }
            }
            
            let existSubSets = result
            for existSubset in existSubSets {
                var subset = existSubset
                for _ in 0..<dupCount {
                    subset.append(nums[index])
                    result.append(subset)
                }
            }
            index += dupCount
        }
        return result
    }
}

---

16ms

class Solution {
    func subsetsWithDup(_ nums: [Int]) -> [[Int]] {
        
        if nums.count == 0 {
            return []
        }
        
        var nums = nums.sorted()
        var result = [[Int]]()
        result.append([])
        var size = 1, last = nums[0]
        for i in 0..<nums.count {
            if last != nums[i] {
                last = nums[i]
                size = result.count
            }
            let newSize = result.count
            for j in newSize - size..<newSize {
                var out = result[j] + [nums[i]]
                result.append(out)
            }
        }
        return result
    }
}

---

96ms

class Solution {
    func subsetsWithDup(_ nums: [Int]) -> [[Int]] {
        guard !nums.isEmpty else {
            return []
        }
        var sorted = nums
        sorted.sort(by:<)
        var result = [[Int]]()
        for num in sorted {
            for i in 0..<result.count {
                var item = result[i]
                item.append(num)
                if !result.contains(item) {
                    result.append(item)
                }

            }
            var newArray = [num]
            if !result.contains(newArray) {
                result.append(newArray)
            }   
        }
        result.append([])
        return result
    }
}

---

132ms

class Solution {
    
func subsetsWithDup(_ nums: [Int]) -> [[Int]] {
     let nums = nums.sorted()
    var r = [[Int]]()
     subsetsWithDuph(nums, 0,[Int](),&r)
    return r
}
    func subsetsWithDuph(_ nums: [Int], _ i:Int,_ tep:[Int], _ r:inout [[Int]]){
        
        if i == nums.count-1 {
            var tep = tep
            if (!r.contains(tep)) {
                r.append(tep)
            }
            
            tep.append(nums[i])
            
            if (!r.contains(tep)) {
                r.append(tep)
            }           
            return
        }
        var tep = tep
        subsetsWithDuph(nums,i+1,tep,&r)
        tep.append(nums[i])
        subsetsWithDuph(nums,i+1,tep,&r)
    }
}

---

 136ms

class Solution {
    func subsetsWithDup(_ nums: [Int]) -> [[Int]] {
        var result = [[Int]()]
        guard nums.count > 0 else { return result }
        
        func test(_ array: [[Int]], _ current: Int) -> [[Int]] {
            var result = array
            for temp in array {
                var a = temp
                a.append(current)
                if !result.contains(a) {
                    result.append(a)    
                }
            }
            return result
        }
        
        for num in nums.sorted() {
            result = test(result, num)
        }
        return result
    }
}