[LeetCode] 39. Combination Sum（组合的和）

• Difficulty: Medium

• Related Topics: Array, Backtracking

• Link: https://leetcode.com/problems/combination-sum/

Description

Given an array of distinct integer candicates and a target integer target, return a list of all unique combination of candidates where chosen numbers sum to target. You may return the combinations in any order.
给一个由互不相同的整数组成的数组 candidates 和一个整数 target，返回一个列表，列表里包含所有互异组合，组合里的元素来自于 candidates，且这些元素的和等于 target。你可以以任何顺序返回答案。

The same number may be chosen from candidates an unlimited number of times. Two combinations are unique if the frequency of at least one of the chosen numbers is different.
相同的数可以使用若干次。对于两个组合，如果至少一个数出现的频率不同，则认定其为不同的组合

It is guaranteed that the number of unique combinations that sum up to target is less than 150 combinations of the given input.
输入保证满足条件的组合元素小于 150 个。

Examples

Example 1

Input: candidates = [2,3,6,7], target = 7
Output: [[2,2,3],[7]]
Explanation:
2 and 3 are candidates, and 2 + 2 + 3 = 7. Note that 2 can be used multiple times.
7 is a candidate, and 7 = 7.
These are the only two combinations.

Example 2

Input: candidates = [2,3,5], target = 8
Output: [[2,2,2,2],[2,3,3],[3,5]]

Example 3

Input: candidates = [2], target = 1
Output: []

Example 4

Input: candidates = [1], target = 1
Output: [[1]]

Example 5

Input: candidates = [1], target = 2
Output: [[1,1]]

Constraints

• 1 <= candidates.length <= 30

• 1 <= candidates[i] <= 200

• All elements of candidates are distinct

• 1 <= target <= 500

Solution

这题暴力搜索是比较简单的，不过在暴力搜索前可以把 candidates 排下序，方便剪枝。代码如下：

class Solution {
    private val result = hashSetOf<List<Int>>()

    fun combinationSum(candidates: IntArray, target: Int): List<List<Int>> {
        candidates.sort()
        backtrack(candidates, 0, target, arrayListOf())
        return result.toList()
    }

    private fun backtrack(candidates: IntArray, curIndex: Int, target: Int, combination: MutableList<Int>) {
        if (target < 0) {
            return
        }
        if (target == 0) {
            result.add(combination.sorted())
        }
        for (i in curIndex..candidates.lastIndex) {
            if (target >= candidates[i]) {
                combination.add(candidates[i])
                backtrack(candidates, curIndex, target - candidates[i], combination)
                combination.removeAt(combination.lastIndex)
            }
        }
    }
}