[Swift]LeetCode377. 组合总和 Ⅳ | Combination Sum IV

原文地址：https://www.cnblogs.com/strengthen/p/10278399.html 

Given an integer array with all positive numbers and no duplicates, find the number of possible combinations that add up to a positive integer target.

Example:

nums = [1, 2, 3]
target = 4

The possible combination ways are:
(1, 1, 1, 1)
(1, 1, 2)
(1, 2, 1)
(1, 3)
(2, 1, 1)
(2, 2)
(3, 1)

Note that different sequences are counted as different combinations.

Therefore the output is 7. 

Follow up:
What if negative numbers are allowed in the given array?
How does it change the problem?
What limitation we need to add to the question to allow negative numbers?

---

给定一个由正整数组成且不存在重复数字的数组，找出和为给定目标正整数的组合的个数。

示例:

nums = [1, 2, 3]
target = 4

所有可能的组合为：
(1, 1, 1, 1)
(1, 1, 2)
(1, 2, 1)
(1, 3)
(2, 1, 1)
(2, 2)
(3, 1)

请注意，顺序不同的序列被视作不同的组合。

因此输出为 7。

进阶：
如果给定的数组中含有负数会怎么样？
问题会产生什么变化？
我们需要在题目中添加什么限制来允许负数的出现？

---

 8ms

class Solution {
    func combinationSum4(_ nums: [Int], _ target: Int) -> Int {       
        var memo = [Int](repeating: 0, count: target+1)
        memo[0] = 1        
        for num in 1...target {            
            for i in 0..<nums.count {                
                if num >= nums[i] {                    
                    if memo[num] == Int.max - memo[num-nums[i]] { 
                        return 1                        
                    }else if memo[num] > Int.max - memo[num-nums[i]]{ 
                        return 0
                    }                    
                    memo[num] += memo[num-nums[i]]                    
                }
            }
        }        
        return memo[target]
    }
}

---

12ms

class Solution {
    func combinationSum4(_ nums: [Int], _ target: Int) -> Int {
        var dp = [Int](repeating: -1, count: target + 1)
        dp[0] = 1
        return _helper(nums, target, &dp)
    }
    
    fileprivate func _helper(_ nums: [Int], _ target: Int, _ dp: inout [Int]) -> Int {
        if dp[target] != -1 {
            return dp[target]
        }
        
        var res = 0
        for num in nums {
            if target >= num {
                res += _helper(nums, target - num, &dp)
            }
        }
        
        dp[target] = res
        
        return res
    }
}

---

12ms

class Solution {
    func combinationSum4(_ nums: [Int], _ target: Int) -> Int {
        if nums.isEmpty
        {
            return 0
        }
        var map:[Int:Int] = [Int:Int]()
        return countCombination(nums, target, &map)        
    }
    
    func countCombination(_ nums: [Int], _ target: Int,_ map:inout[Int:Int]) -> Int
    {
        if map[target] != nil
        {
            return map[target]!
        }
        var result:Int = 0
        for i in 0..<nums.count
        {
            if nums[i] < target
            {
                result += countCombination(nums, target - nums[i], &map)
            }
            else if nums[i] == target
            {
                result += 1
            }
        }
        map[target] = result
        return result
    }
}

---

20ms

class Solution {
    
    var cache:[Int:Int] = [:]
    var nums:[Int] = []
    
    func combinationSum4(_ nums: [Int], _ target: Int) -> Int {
        return combinationSum(nums, target)        
        // return combs.count
    }
    
    func combinationSum(_ nums:[Int], _ target: Int) -> Int {
        
        if self.cache[target] == nil {
            var combs:Int = 0

            for num in nums {
                if num == target {
                    combs += 1
                } 

                if num < target {
                    combs += combinationSum(nums, target-num)
                }
            }

            self.cache[target] = combs
        }
        
        return self.cache[target]!
    }
}

---

24ms

class Solution {
    var cache = [Int: Int]()
    func combinationSum4(_ nums: [Int], _ target: Int) -> Int {
        cache = [:]
        return helper(nums, target)
    }
    
    private func helper(_ nums: [Int], _ target: Int) -> Int {
        guard target >= 0 else { return 0 }
        guard target > 0 else { return 1 }
        guard cache[target] == nil else { return cache[target]! }
        
        let result = nums.map { helper(nums, target - $0) }.reduce(0) { $0 + $1 }
        cache[target] = result
        
        return result
    }
}