[Swift]LeetCode39. 组合总和 | Combination Sum

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

Given a set of candidate numbers (candidates) (without duplicates) and a target number (target), find all unique combinations in candidates where the candidate numbers sums to target.

The same repeated number may be chosen from candidates unlimited number of times.

Note:

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

Example 1:

Input: candidates = [2,3,6,7], target = 7,
A solution set is:
[
  [7],
  [2,2,3]
]

Example 2:

Input: candidates = [2,3,5], target = 8,
A solution set is:
[
  [2,2,2,2],
  [2,3,3],
  [3,5]
]

---

给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的数字可以无限制重复被选取。

说明：

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

示例 1:

输入: candidates = [2,3,6,7], target = 7,
所求解集为:
[
  [7],
  [2,2,3]
]

示例 2:

输入: candidates = [2,3,5], target = 8,
所求解集为:
[
  [2,2,2,2],
  [2,3,3],
  [3,5]
]

---

20ms

class Solution {
    var result = [[Int]]()
    func combinationSum(_ candidates: [Int], _ target: Int) -> [[Int]] {
        combinationSum(candidates, target, 0, [Int]())
        return result
    }
    
    func combinationSum(_ candidates: [Int], _ target: Int, _ currentInex: Int, _ usdedNums: [Int]) {
        if target <= 0  {
            if target == 0 {
                result.append(usdedNums)               
            }
            return
        }
        for i in currentInex..<candidates.count {
            let currentValue = candidates[i]
            if currentValue > target {
                continue
            }
            var usdedNumsCopy = usdedNums
            usdedNumsCopy.append(currentValue)
            combinationSum(candidates, target-currentValue, i, usdedNumsCopy)
        }
    }
}

---

24ms

class Solution {
    func combinationSum(_ candidates: [Int], _ target: Int) -> [[Int]] {
        let candidatesCopy = candidates.sorted{ $0 < $1 }
        var tmp = [Int]()
        var res = [[Int]]()
        var index = 0
        helper(&tmp, &res, index, candidatesCopy, target)
        return res
    }
    
    private func helper(_ tmp: inout [Int], _ res: inout [[Int]], _ index: Int, _ candidatesCopy: [Int], _ target: Int) {
        if target == 0 {
            res.append(tmp)
            return
        }else if index == candidatesCopy.count {
            return
        }
        
        for i in index..<candidatesCopy.count {
            if candidatesCopy[i] > target {
                return
            }else if i != index && candidatesCopy[i] == candidatesCopy[i - 1] {
                continue
            }
            
            tmp.append(candidatesCopy[i])
            helper(&tmp, &res, i, candidatesCopy, target - candidatesCopy[i])
            tmp.removeLast()
        }
    }
}

---

28ms

class Solution {
    func combinationSum(_ candidates: [Int], _ target: Int) -> [[Int]] {
        var result = [[Int]]()
        var out = [Int]()
        var candidates = candidates.sorted()
        combinationSumDFS(candidates, target, 0, &out, &result)
        return result
    }
    
    func combinationSumDFS(_ candidates: [Int], _ target: Int, _ start: Int, _ out: inout [Int], _ res: inout [[Int]]) {
        if target == 0 {
            res.append(out)
        } else {
            for i in start..<candidates.count {
                guard target - candidates[i] >= 0 else {
                    break
                }
                out.append(candidates[i])
                combinationSumDFS(candidates, target - candidates[i], i, &out, &res)
                out.remove(at: out.count - 1)
                
            }
        }
    }
    
}

---

28ms

class Solution {
    
    var list = [[Int]]()
    
    func combinationSum(_ candidates: [Int], _ target: Int) -> [[Int]] {
        var currentlySelected = [Int]()
        recursiveCombSum(candidates: candidates, index: 0, target: target, currentlySelected: currentlySelected)
        return list
    }
    
    func recursiveCombSum(candidates: [Int], index: Int, target: Int, currentlySelected: [Int]) {
        if 0 == target {
            list += [currentlySelected]
        }
        if index == candidates.count {
        } else {
            for i in index..<candidates.count {
                if candidates[i] <= target {
                    var newTarget = target - candidates[i]
                    var newList = currentlySelected + [candidates[i]]
                    recursiveCombSum(candidates: candidates, index: i, target: newTarget, currentlySelected: newList)
                }
            }
        }
    }
}

---

56ms

class Solution {
    var conbineArray = [[Int]]()
    func combinationSum(_ candidates: [Int], _ target: Int) -> [[Int]] {
        let count = candidates.count
        guard count > 0 else {
            return [[Int]]()
        }
        combine(candidates, [Int](), count, 0, target)
        return conbineArray
    }
    
    func combine(_ candidates: [Int], _ currentCombine: [Int], _ count: Int, _ index: Int, _ target: Int) {
        if target < 0 { return }
        if index == count { return }
        if target == 0 {
            conbineArray.append(currentCombine)
            return
        }
        
        combine(candidates, currentCombine, count, index + 1, target)
        var currentCombine = currentCombine
        currentCombine.append(candidates[index])
        combine(candidates, currentCombine, count, index, target - candidates[index])
    }
}