[LeetCode][JavaScript]Combination Sum

Combination Sum 

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

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

Note:

• All numbers (including target) will be positive integers.
• Elements in a combination (a1, a2, … , ak) must be in non-descending order. (ie, a1 ≤ a2 ≤ … ≤ ak).
• The solution set must not contain duplicate combinations.

 

For example, given candidate set 2,3,6,7 and target 7, 
A solution set is: 
[7] 
[2, 2, 3] 

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

 

 

---

 

 

第一遍的代码如下，写的时候就不是很满意，套了三层循环。

思路就是粗暴迭代，拿题目的例子来说，7可以是2+5,3+4,6+1和7。然后里面的5就递归调用combinationNumber(5), 4调用combinationNumber(4)。

虽然AC了但是624ms相当不理想，别的OJ可能就TLE了，主要是有太多重复的情况，要花时间去剔除掉。

然后去看了官方攻略http://articles.leetcode.com/2010/09/print-all-combinations-of-number-as-sum.html

说了一堆有的没的，我理解了一下其实就是dfs，只不过每个节点可以重复走。

注意到1. 比如递归到3的时候，不要再回去找包含2的结果，因为会有重复的情况。

2.不剪枝就超时或者堆栈爆炸......

 

旧版：

/**
 * @param {number[]} candidates
 * @param {number} target
 * @return {number[][]}
 */
var combinationSum = function(candidates, target) {
    candidates.sort(sorting);
    return combinationNumber(target);

    function combinationNumber(num){
        var res = [];
        for(var i = 0; num - candidates[i] >= 0; i++){
            if(candidates[i] === num){
                res.push([num]);
            }
            var tmpArr = combinationNumber(num - candidates[i]);
            if(tmpArr.length !== 0){
                for(var j in tmpArr){
                    tmpArr[j].push(candidates[i]);
                    tmpArr[j].sort(sorting);
                    var hasArr = false;
                    for(var k in res){
                        if(isSameArray(res[k], tmpArr[j])){
                            hasArr = true;
                            break;
                        }
                    }
                    if(!hasArr){
                        res.push(tmpArr[j]);
                    }
                }
            }
        }
        return res;
    }
    function sorting(a, b){
        if(a > b){
            return 1;
        }else if(a < b){
            return -1;
        }else{
            return 0;
        }
    }
    function isSameArray(a, b){
        if(a.length !== b.length){
            return false;
        }
        for(var i in a){
            if(a[i] !== b[i]){
                return false;
            }
        }
        return true;
    }  
};

 

新版：

/**
 * @param {number[]} candidates
 * @param {number} target
 * @return {number[][]}
 */
var combinationSum = function(candidates, target) {
    var res = [];
    candidates.sort(sorting);
    dfs(0, 0, []);
    return res;

    function dfs(sum, index, tmp){
        if(sum === target){
            newTmp = tmp.concat();
            res.push(newTmp);
            return; //pruning
        }else if(sum > target){
            return; //pruning
        }
        for(var i = index; i < candidates.length; i++){ 
            newTmp = tmp.concat();
            newTmp.push(candidates[i]);
            dfs(sum + candidates[i], i, newTmp);
        }    
    }
    function sorting(a, b){
        if(a > b){
            return 1;
        }else if(a < b){
            return -1;
        }else{
            return 0;
        }
    }
};