LeetCode - Combination Sum

Combination Sum

2013.12.15 03:10

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] 

Solution:

　　Given a set of candidate numbers, find all the combinations that add up to a target value. Every element can be used infinite times.

　　Since every element can be used unlimited times, the first step will be to remove the duplicates from the array.

　　Next step, sort the array.

　　Then do the DFS, with proper pruning technique.

　　Time complexity is roughly O(n!), where n is number of elements in the unique and sorted array. Space complexity is O(n), which is required by the unique and sorted array. Some bad cases can be very tricky to handle, guess my code here won't solve them...

Accepted code:

// 1WA, 1OLE, 1AC, dfs trimming condition is a weak point.
#include <algorithm>
using namespace std;

class Solution {
public:
    vector<vector<int> > combinationSum(vector<int> &candidates, int target) {
        // Note: The Solution object is instantiated only once and is reused by each test case.
        int i, j, n;
        
        n = result.size();
        for(i = 0; i < n; ++i){
            result[i].clear();
        }
        result.clear();
        
        sort(candidates.begin(), candidates.end());
        v.clear();
        i = 0;
        n = candidates.size();
        // remove duplicates from candidates
        while(i < n){
            j = i + 1;
            while(j < n && candidates[i] == candidates[j]){
                ++j;
            }
            v.push_back(candidates[i]);
            i = j;
        }
        
        arr.clear();
        n = v.size();
        dfs(0, n, 0, target);
        
        return result;
    }
private:
    vector<int> v;
    vector<int> arr;
    vector<vector<int>> result;
    
    void dfs(int idx, int n, int sum, int target) {
        int i, j, k;
        
        if(sum == target){
            result.push_back(arr);
            return;
        }
        
        // 1WA here, if(idx >= n || sum > target) is wrong, must check $sum first.
        if(sum > target){
            return;
        }

        for(i = idx; i < n; ++i){
            for(j = 1; sum + v[i] * j <= target; ++j){
                for(k = 0; k < j; ++k){
                    arr.push_back(v[i]);
                }
                dfs(i + 1, n, sum + v[i] * j, target);
                for(k = 0; k < j; ++k){
                    // 1OLE here, $arr, not $v
                    arr.pop_back();
                }
            }
        }
    }
};