LeetCode: Combination Sum

#include<iostream>
#include<vector>
#include<map>
using namespace::std;

class Solution {
public:
vector<vector<int> > combinationSum(vector<int> & candidates, int target) {
map<int, vector<vector<int> > > result;
for(int i = 0; i <= target; i++)
{
for(size_t j = 0; j < candidates.size(); j++)
{
if(i - candidates[j] < 0)
{
continue;
}
else if(i - candidates[j] == 0)
{
vector<int> tmp;
tmp.push_back(candidates[j]);
result[i].push_back(tmp);
}
else
{
int diff = i - candidates[j];
//cout<<"i = "<<i<<endl;
//cout<<diff<<endl;
if(result.find(diff) == result.end())

continue;
else
{
for(int x = 0; x <result[diff].size(); x++)
{
if(candidates[j] >= result[diff][x].back())
{
vector<int> tmp_vec(result[diff][x]);
tmp_vec.push_back(candidates[j]);
result[i].push_back(tmp_vec);
}
}
}
}

}
}
return result[target];
}
};

int main()
{
vector<int> input;
input.push_back(1);
Solution ss;
ss.combinationSum(input, 2);
}

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 2: Using DFS

#include<iostream>
#include<vector>
#include<map>
#include <algorithm>
using namespace::std;

#include <algorithm>
#include <algorithm>

class Solution {
public:
void getsum(vector<int> & cands, int target, int start, vector<vector<int> > &results, vector<int> path){
if(target == 0){ // found the sum
results.push_back(path);
return;
}
if(start >= cands.size() || target < 0) return; //reach the end of candidates
if(cands[start] > target)
getsum(cands, target, start+1, results, path); //skip this element
else{
int pre = -1;
// exclude cands[start]
for(int i = start; i < cands.size(); i++)
{
// include cands[start]
if(cands[i] != pre)
{
path.push_back(cands[i]);
getsum(cands,target-cands[i],i,results,path);
pre = path.back();
path.pop_back();
}
}
}
}
vector<vector<int> > combinationSum(vector<int> &candidates, int target) {
// Start typing your C/C++ solution below
// DO NOT write int main() function
vector<vector<int> > results;
vector<int> path;
getsum(candidates,target,0,results,path);
for(int i=0; i<results.size(); i++){
sort(results[i].begin(),results[i].end());
}
return results;
}
};

int main()
{
vector<int> input;
input.push_back(1);
input.push_back(2);
//input.push_back(10);
Solution ss;

vector<vector<int> > result = ss.combinationSum(input, 1);
for(int i = 0; i < result.size(); i++)
{
for(int j = 0; j < result[i].size(); j++)
{
cout<<result[i][j];

}
cout<<endl;
}
}