LeetCode - 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]

class Solution {
public:
void findPath(set<vector<int> >& numSet, vector<vector<int> >& dp,
vector<int> &candidates, vector<int>& path,int value){
if(value==0){
vector<int> tmp(path);
sort(tmp.begin(),tmp.end());
numSet.insert(tmp);
return;
}
for(int i=0;i<dp.size();i++){
if(dp[i][value]!=-1){
path.push_back(candidates[i]);
findPath(numSet,dp,candidates,path,dp[i][value]);
path.pop_back();
}
}
}

vector<vector<int> > combinationSum(vector<int> &candidates, int target) {
vector<vector<int> > result;
if(candidates.empty()||candidates.size()==0){
return result;
}

int n=candidates.size();
sort(candidates.begin(),candidates.end());

vector<vector<int> > dp(n,vector<int>(target+1,-1));
set<vector<int> > numSet;
vector<bool> visited(target+1,false);
vector<int> path;
visited[0]=true;

for(int i=0;i<n;i++){
if(candidates[i]>target){
break;
}
for(int j=candidates[i];j<=target;j++){
if(visited[j-candidates[i]]==true){
dp[i][j]=j-candidates[i];
visited[j]=true;
}
}
}

findPath(numSet,dp,candidates,path,target);
result.assign(numSet.begin(),numSet.end());
return result;
}
};