[Swift]LeetCode216. 组合总和 III | Combination Sum III

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

Find all possible combinations of k numbers that add up to a number n, given that only numbers from 1 to 9 can be used and each combination should be a unique set of numbers.

Note:

• All numbers will be positive integers.
• The solution set must not contain duplicate combinations.

Example 1:

Input: k = 3, n = 7
Output: [[1,2,4]]

Example 2:

Input: k = 3, n = 9
Output: [[1,2,6], [1,3,5], [2,3,4]]

---

找出所有相加之和为 n 的 k 个数的组合。组合中只允许含有 1 - 9 的正整数，并且每种组合中不存在重复的数字。

说明：

• 所有数字都是正整数。
• 解集不能包含重复的组合。 

示例 1:

输入: k = 3, n = 7
输出: [[1,2,4]]

示例 2:

输入: k = 3, n = 9
输出: [[1,2,6], [1,3,5], [2,3,4]]

---

8ms

class Solution {
    func combinationSum3(_ k: Int, _ n: Int) -> [[Int]] {
        guard k > 0, n > 0  else {
            return [[Int]]() 
        }
        
        var result = [[Int]]()
        
        func dfs(index:Int,target:Int, path:[Int]) {
            if target == 0 && path.count == k {
                result.append(path)
                return
            } else if target < 0 || index > 9 || path.count >= k {
                return 
            }
           
            for i in index...9 {
                dfs(index:i + 1, target: target - i, path:path + [i])
            }
        }
        dfs(index:1, target:n, path:[Int]())
        
        return result
    }
}

---

12ms

class Solution {
    func combinationSum3(_ k: Int, _ n: Int) -> [[Int]] {
        var res = [[Int]]()
        var temp = [Int]()
        dfs(&res, &temp, n, k, 1)
        return res
    }
    
    private func dfs(_ res: inout [[Int]], _ temp: inout [Int], _ n: Int, _ k: Int, _ index: Int) {
        if n == 0 && k == 0 {
            res.append(Array(temp))
            return
        }
        if n <= 0 || k == 0 || index > 9  {
            return
        }
        for i in index...9 {
            temp.append(i)
            dfs(&res, &temp, n - i, k - 1, i + 1)
            temp.removeLast()
        }
    }
}

---

12ms

class Solution {
        func combinationSum3(_ k: Int, _ n: Int) -> [[Int]] {
        var res = [Set<Int>]()
        var cur = Set<Int>()
        let nums : Set<Int> = [1,2,3,4,5,6,7,8,9]
        sumHelp(k, n, &cur, &res, nums)
        
        return res.map{Array($0)}
    }
    
    func sumHelp(_ k : Int, _ n : Int,_ cur : inout Set<Int>, _ res : inout [Set<Int>], _ nums : Set<Int>) {
        if k == 1 {
            if nums.contains(n) && !cur.contains(n) {
                cur.insert(n)
                res.append(cur)
                cur.remove(n)
            }
        }else {
            for i in nums where i * 2 < n && i > cur.max() ?? 0 {
                cur.insert(i)
                var set = nums
                set.remove(i)
                sumHelp(k - 1, n - i, &cur, &res, set)
                cur.remove(i)
            }
        }
    }
}

---

16ms

 1 class Solution {
 2     func combinationSum3(_ k: Int, _ n: Int) -> [[Int]] {
 3         var array = [Int]()
 4         for i in 1 ... 9 {
 5             array.append(i)
 6         }
 7         
 8         var result = [[Int]]()
 9         
10         func helper(remain: [Int], current: [Int], sum: Int) {
11             var newRemain = remain
12             while newRemain.count > 0 {
13                 let temp = newRemain.removeFirst()
14                 var newCurrent = current
15                 newCurrent.append(temp)
16                 let newSum = sum + temp
17                 if newSum == n && newCurrent.count == k {
18                     result.append(newCurrent)
19                 } else if newSum > n {
20                     continue
21                 } else {
22                     helper(remain: newRemain, current: newCurrent, sum: newSum)
23                 }
24             }
25         }
26         
27         helper(remain: array, current: [Int](), sum: 0)
28         return result
29     }
30 }

---

20ms

import Foundation

class Solution {
  func combinationSum3(_ k: Int, _ n: Int) -> [[Int]] {
    var cacheMap = [String: [[Int]]]()
    return createConbination(count: k, target: n, prefix: [Int](), cacheMap: &cacheMap)
  }

  func createConbination(count: Int, target: Int, prefix: [Int], cacheMap: inout [String: [[Int]]]) -> [[Int]] {
    if count == 0 || target == 0 {
      return [prefix]
    }


    var minValue = 1
    if let lastNumber = prefix.last {
      minValue = lastNumber + 1
    }
    minValue = max(minValue, target - 9 * (count - 1))
    let maxValue = min(9, target - (count - 1))
    if minValue > maxValue {
      return [[Int]]()
    }

    let key = String(format: "%d_%d_%d", count, target, minValue)
    if let cachedValue = cacheMap[key] {
      var output = [[Int]]()
      for sequence in cachedValue {
        var newSequence = prefix
        let lastIndex = sequence.count - 1
        let suffix = sequence[lastIndex - count + 1...lastIndex]
        newSequence.append(contentsOf: suffix)
        output.append(newSequence)
      }
      return output
    }

    var output = [[Int]]()
    for num in minValue...maxValue {
      var newPrefix = prefix
      newPrefix.append(num)
      let newArray = createConbination(count: count - 1, target: target - num, prefix: newPrefix, cacheMap: &cacheMap)
      output.append(contentsOf: newArray)
    }

    cacheMap[key] = output
    return output
  }
}

---

24ms

class Solution {
    func combinationSum3(_ k: Int, _ n: Int) -> [[Int]] {
        var result: [[Int]] = []
        combinationSum3(k, n, [], 1, &result)
        return result
    }

    func combinationSum3(_ k: Int, _ remain: Int, _ nums: [Int], _ index: Int, _ result: inout [[Int]]) {
        if nums.count > k || remain < 0 {
            return
        }

        if nums.count == k && remain == 0 {
            result.append(nums)
            return
        }
        
        let loopCount = min(remain, 9)
        if index > loopCount {
            return
        }

        var nums = nums
        for num in index...loopCount {
            nums.append(num)
            combinationSum3(k, remain - num, nums, num + 1, &result)
            nums.removeLast()
        }
    }
}