LeetCode

Combinations

2013.12.22 05:17

Given two integers n and k, return all possible combinations of k numbers out of 1 ... n.

For example,
If n = 4 and k = 2, a solution is:

[
  [2,4],
  [3,4],
  [2,3],
  [1,2],
  [1,3],
  [1,4],
]

Solution:

　　Combination and permutation problems are usually solved with DFS recursion.

　　When solving C(n, k), we pick one element from the candidate set, and solve C(n - 1, k - 1) with the remaining set.

　　Time complexity is, eh ...O(C(n, 0) + C(n, 1) + ... + C(n, k)), because the subset (1, 3, 4) comes only after you've searched (1) and (1, 3). ALL smaller subsets must be traversed to get the desired subsets of size k. Space complexity is O(n).

Accepted code:

// 1AC, very well
class Solution {
public:
    vector<vector<int> > combine(int n, int k) {
        // IMPORTANT: Please reset any member data you declared, as
        // the same Solution instance will be reused for each test case.
        int i;
        for(i = 0; i < result.size(); ++i){
            result[i].clear();
        }
        result.clear();
        
        if(n <= 0 || k <= 0){
            return result;
        }
        
        arr = new int[n];
        dfs(0, 0, n, k);
        delete[] arr;
        
        return result;
    }
private:
    vector<vector<int>> result;
    int *arr;
    
    void dfs(int idx, int cnt, int n, int k) {
        int i;
        
        if(cnt == k){
            result.push_back(vector<int>());
            for(i = 0; i < k; ++i){
                result[result.size() - 1].push_back(arr[i]);
            }
            return;
        }
        
        // trim redundant path to save some time
        if(idx + (k - cnt) > n){
            return;
        }
        
        for(i = idx; i < n; ++i){
            arr[cnt] = i + 1;
            dfs(i + 1, cnt + 1, n, k);
        }
    }
};