LeetCode[39]: 组合总和

Posted 李建明180

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了LeetCode[39]: 组合总和相关的知识,希望对你有一定的参考价值。

中等难度。本来觉得很无聊,但是看到题解中说到剪枝算法,想看一下所以就干脆解一遍。

读题

给定一个无重复元素的数组?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]
]

来源:力扣(LeetCode)
链接:https://leetcode-cn.com/problems/combination-sum
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。

这题看上去非常眼熟,因为之前做过“两数之和”,“三数之和”,这题的区别是不限制多少个数字,所以要穷举。

没有足够的限制条件,所以只能递归了。那么问题就转化为如何优化递归性能了。

实现

func combinationSum(candidates []int, target int) [][]int {
    if len(candidates) == 0 {
        return [][]int{}
    }
    // 注意每次启动时都要初始化所有全局变量
    cd = candidates
    len0039 = len(cd)
    sort.Ints(cd)
    temp0039 = make([]int, target/cd[0]+1)
    result0039 = [][]int{}

    recurCombinationSum(0, 0, target)
    return result0039
}

var cd []int
var len0039 int
var temp0039 []int
var result0039 [][]int

func recurCombinationSum(cdPos, tempPos int, target int) {
    for n := 0; cdPos < len0039; cdPos++ { // 为了可读性,将n单独作为变量
        n = cd[cdPos]
        if n > target {
            return
        }
        temp0039[tempPos] = n
        if n == target {
            newSolution := make([]int, tempPos+1)
            copy(newSolution, temp0039)
            result0039 = append(result0039, newSolution)
            return
        } else {
            recurCombinationSum(cdPos, tempPos+1, target-n)
        }
    }
}

优化思路就是,把一些公共变量放在堆上作为全局变量(而不是作为递归时的参数)(这种方法是线程不安全的,当然改进也很简单,封装为类就好了)

(回溯算法)每次递归时,在temp数组上前进一位,然后target减少;只有找到相等的情况才append,大于就中止,小于就继续递归。

(剪枝)在candidates数组上也要记录位置,防止出现[2,2,3], [2,3,2], [3,2,2]这样的重复解。

提交成绩:

执行用时 :8 ms, 在所有 Go 提交中击败了70.93%的用户
内存消耗 :4.2 MB, 在所有 Go 提交中击败了80.00%的用户

测试用例:

{
    args: args大专栏  LeetCode[39]: 组合总和span>{[]int{2, 3, 6, 7}, 7},
    want: [][]int{
        {2, 2, 3}, {7},
    },
},
{
    args: args{[]int{2, 3, 5}, 8},
    want: [][]int{
        {2, 2, 2, 2}, {2, 3, 3}, {3, 5},
    },
},
{
    name: "无解",
    args: args{[]int{2, 3, 5}, 1},
    want: [][]int{
    },
},
{
    name: "target在中间",
    args: args{[]int{1, 4, 5}, 3},
    want: [][]int{
        {1, 1, 1},
    },
},

稍微改进

忽然想到在命中的时候(叶子节点)就已经可以return了。然后再去掉那个递归中便于阅读的变量n:

func recurCombinationSum(cdPos, tempPos int, target int) {
    for ; cdPos < len0039; cdPos++ {
        if cd[cdPos] > target {
            return
        }
        temp0039[tempPos] = cd[cdPos]
        if cd[cdPos] == target {
            newSolution := make([]int, tempPos+1)
            copy(newSolution, temp0039)
            result0039 = append(result0039, newSolution)
            return
        } else {
            recurCombinationSum(cdPos, tempPos+1, target-cd[cdPos])
        }
    }
}

提交成绩:

执行用时 :4 ms, 在所有 Go 提交中击败了94.83%的用户
内存消耗 :4.3 MB, 在所有 Go 提交中击败了80.00%的用户

其他思路

看了题解,发现我自己的思路就是所谓的回溯+剪枝,其实思路很简单,加上名字好像就变得高大上了。

还有所谓的深度优先,其实对于这题应该只有深度优先,广度优先应该不可行。

然后还看到奇葩用动态规划来解??光是想想就很难受,真亏他做得出来……

以上是关于LeetCode[39]: 组合总和的主要内容,如果未能解决你的问题,请参考以下文章

回溯leetCode高频:39. 组合总和

LeetCode——39. 组合总和

leetcode39.组合总和

LeetCode[39]: 组合总和

Leetcode 39 组合总和(回溯算法解题)

递归与回溯6:LeetCode39组合总和(可重复使用)