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 (a₁, a₂, … , a_k) must be in non-descending order. (ie, a₁ ≤ a₂ ≤ … ≤ a_k).
• 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;
	}
}