LeetCode - Combination Sum II

Combination Sum II

2013.12.15 03:51

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

Each number in C may only be used once in the combination.

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 10,1,2,7,6,1,5 and target 8, 
A solution set is: 
[1, 7] 
[1, 2, 5] 
[2, 6] 
[1, 1, 6] 

Solution:

　　"Find all combinations that add up to a target value." This is a typical DFS problem.

　　First step, sort the array.

　　Second step, depth first searching with pruning technique.

　　Use some kind of hashing or signature algorithm to make sure no duplicate combinations are put in the result set.

　　Time complexity is roughly O(2^n), space complexity is O(n).

Accepted code:

// 1WA, 1AC, #include <algorithm>
// 1WA here, must include algorithm, otherwise sort() would act unexpectedly
#include <algorithm>
using namespace std;

class Solution {
public:
    vector<vector<int> > combinationSum2(vector<int> &num, 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(num.begin(), num.end());
        v.clear();
        count.clear();
        i = 0;
        n = num.size();
        // remove duplicates from num
        while(i < n){
            j = i + 1;
            while(j < n && num[i] == num[j]){
                ++j;
            }
            v.push_back(num[i]);
            count.push_back(j - i);
            i = j;
        }
        
        arr.clear();
        n = v.size();
        dfs(0, n, 0, target);
        
        return result;
    }
private:
    vector<int> v;
    vector<int> arr;
    vector<int> count;
    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;
        }
        
        if(sum > target){
            return;
        }

        for(i = idx; i < n; ++i){
            for(j = 1; sum + v[i] * j <= target && j <= count[i]; ++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){
                    arr.pop_back();
                }
            }
        }
    }
};