vector<vector<int> > combinationSum(vector<int> &candidates, int target) {
sort(candidates.begin(),candidates.end());
vector<vector<int> > r;
vector<int> v;
combinationSum(candidates, target, 0, v, r);
return r;
}
void combinationSum(set<vector<int> > &res, vector<int> &cur_res, vector<int> &candidates, int idx, int target)
{
if(target == 0)
{
res.insert(cur_res);
return;
}
if(target < 0)
return;
if(idx >= candidates.size())
return;
combinationSum(res, cur_res, candidates, idx + 1, target);
cur_res.push_back(candidates[idx]);
combinationSum(res, cur_res, candidates, idx + 1, target - candidates[idx]);
cur_res.erase(cur_res.end()-1);
}
vector<std::vector<int> > combinationSum(std::vector<int> &candidates, int target) {
sort(candidates.begin(), candidates.end());
vector<std::vector<int> > res;
vector<int> tmp;
combinationSum(candidates,tmp,res,target, 0);
return res;
}
int main(){
// int arr[] = {2,3,6,7};
int arr[] = {8,7,4,3};
vector<int> candidates(arr, arr + sizeof(arr) / sizeof(int));
print_2D_int(combinationSum(candidates, 11));
return 0;
}
vector<vector<int> > combinationSum(vector<int> &candidates, int target) {
sort(candidates.begin(), candidates.end());
vector<vector<int> > result;
combinationSum(candidates, 0, target, result);
return result;
}
vector<vector<int>> combinationSum01(vector<int>& candidates, int target) {
vector<int> pos;
for (int i = 0; i < candidates.size(); ++i)
{
if (candidates[i] <= target)
{
pos.push_back(candidates[i]);
}
}
if (target == 0) return{ {} };
if (pos.empty()) return{};
sort(pos.begin(), pos.end());
vector<vector<int>> result;
for (int i = 0; i < pos.size(); ++i)
{
vector<int> v2(pos.begin() + i, pos.end());
vector<vector<int>> res_tmp = combinationSum(v2, target - pos[i]);
//if (res_tmp.empty()) return{};
for (int j = 0; j < res_tmp.size(); ++j)
{
res_tmp[j].push_back(pos[i]);
result.push_back(res_tmp[j]);
}
}
return result;
}
set<vector<int> > combinationSum(vector<int> &candi, int curPos, int target){
set<vector<int> > ret;
if( target <= 0 || curPos >= candi.size() )
return ret;
for( int i = curPos; i < candi.size(); i++ ){
if( candi[i] > target )
break;
if( candi[i] == target ){
vector<int> hit;
hit.push_back(candi[i]);
ret.insert(hit);
}
else{
set<vector<int> > subSet = combinationSum(candi, i+1, target-candi[i]); // the only difference with question 39!
if( subSet.empty() )
continue;
for( set<vector<int>>::iterator it = subSet.begin(); it != subSet.end(); ++it ){
vector<int> hit;
hit.push_back(candi[i]);
appendToVector(hit, *it);
ret.insert(hit);
}
}
}
return ret;
}
vector<vector<int> > combinationSum(vector<int> &candidates, int target) {
sort(candidates.begin(), candidates.end());
vector<vector<int> > res;
vector<int> combination;
combinationSum(candidates, target, res, combination, 0);
return res;
}
vector<vector<int> > combinationSum(vector<int> &candidates, int target) {
// Start typing your C/C++ solution below
// DO NOT write int main() function
r.clear();
vector<int> c;
sort(candidates.begin(), candidates.end());
combinationSum(candidates, target, c, 0);
return r;
}
vector<vector<int> > combinationSum2(vector<int> &num, int target) {
vector<vector<int> > ret;
sort(num.begin(), num.end());
set<vector<int> > retSet = combinationSum(num, 0, target);
for(set<vector<int> >::iterator it = retSet.begin(); it != retSet.end(); ++it)
ret.push_back(*it);
return ret;
}
void combinationSum(vector<int> &candidates,vector<int> &tmp, vector<vector<int> > &res,int target, int begin) {
if (!target) {
res.push_back(tmp);
return;
}
for (int i = begin; i != candidates.size() && target >= candidates[i]; ++i) {
tmp.push_back(candidates[i]);
combinationSum(candidates, tmp, res, target - candidates[i], i);
tmp.pop_back();
}
}
vector<vector<int> > combinationSum(vector<int> &candidates, int target) {
vector<vector<int> > ret;
sort(candidates.begin(), candidates.end());
set<vector<int> > retSet = combinationSum(candidates, 0, target);
for(set<vector<int> >::iterator it = retSet.begin(); it != retSet.end(); ++it)
ret.push_back(*it);
return ret;
}
void combinationSum(vector<int> &candidates, int target, vector<vector<int> > &res, vector<int> &combination, int begin) {
if (target == 0) {
res.push_back(combination);
return;
}
for (int i = begin; i != candidates.size() && target >= candidates[i]; ++i) {
combination.push_back(candidates[i]);
// combinations with candidates[i] being the smallest number
combinationSum(candidates, target - candidates[i], res, combination, i);
combination.pop_back();
}
}
void combinationSum(vector<int>& candidates, int idx, int target, vector<vector<int>>& result, vector<int>& combination) {
if (!target){
result.push_back(combination);
return;
}
for (int i = idx; i < candidates.size() && candidates[i] <= target; i++){
if (i > idx && candidates[i] == candidates[i-1]) continue; // here avoid duplication
combination.push_back(candidates[i]);
combinationSum(candidates, i, target - candidates[i], result, combination);
combination.pop_back();
}
}
void combinationSum(vector<int> &can, int gap, int first, vector<int> &v, vector<vector<int> > &r) {
if(gap==0) {
r.push_back(v);
return;
}
for(int i=first;i<can.size();i++) {
if(gap<can[i]) return;
v.push_back(can[i]);
combinationSum(can,gap-can[i],i,v,r);
v.pop_back();
}
}
vector<vector<int> > combinationSum(vector<int> &candidates, int target) {
sort(candidates.begin(), candidates.end());
vector<vector<int> > results;
if (candidates.empty()) return results;
// Use last element
int last = candidates.back();
if (target == last) results.push_back(vector<int>(1, last));
else if (target > last) {
vector<vector<int> > rest = combinationSum(candidates, target - last);
for (int i = 0; i < rest.size(); ++i) {
rest[i].push_back(last);
results.push_back(rest[i]);
}
}
// Not use last element
vector<int> candidates_leave_one(candidates.begin(), candidates.end() - 1);
vector<vector<int> > rest = combinationSum(candidates_leave_one, target);
results.insert(results.end(), rest.begin(), rest.end());
return results;
}
/*
@param : candidates , res return , combination already in , begin start point
*/
void combinationSum(const std::vector<int> &candidates , int target, std::vector<std::vector<int> > &res, std::vector<int> &combination, int begin) {
if (!target) {
res.push_back(combination);
return;
}
for (int i = begin; i != candidates.size() && target >= candidates[i]; ++i) {
combination.push_back(candidates[i]);
combinationSum(candidates, target - candidates[i], res, combination, i);
combination.pop_back();
}
}
vector<vector<int> > combinationSum2(vector<int> &candidates, int target) {
if(candidates.size() == 0)
{
vector<vector<int> > res;
return res;
}
sort(candidates.begin(), candidates.end());
vector<int> cur_res;
set<vector<int> > set_res;
combinationSum(set_res, cur_res, candidates, 0, target);
vector<vector<int> > res(set_res.begin(), set_res.end());
return res;
}
void combinationSum(vector<vector<int>>& res, vector<int>& cur, int k, int remain, int pos) {
if(k == cur.size()) {
if(remain == 0) res.push_back(cur);
return;
}
for (int i = pos; i <= 9; ++i) {
if(remain - i < 0) break;
remain -= i;
cur.push_back(i);
combinationSum(res, cur, k, remain, i+1);
remain += i;
cur.pop_back();
}
}
void combinationSum(vector<int> &candidates, int target, vector<int> &c,
int pos) {
if (pos == candidates.size()) {
if (target == 0) {
vector<int> vc;
for (int i = 0; i < c.size(); i++) {
vc.push_back(c[i]);
}
r.push_back(vc);
}
return;
}
combinationSum(candidates, target, c, pos + 1);
int num = 0;
while(candidates[pos] <= target) {
num++;
target -= candidates[pos];
c.push_back(candidates[pos]);
combinationSum(candidates, target, c, pos + 1);
}
for (int i = 0; i < num; i++) {
c.pop_back();
}
}
int main(int argc, char** argv) {
struct timeval tvStart, tvEnd;
int retSize, *colSizes;
gettimeofday(&tvStart, NULL);
combinationSum(C, sizeof(C) / sizeof(C[0]), T, &colSizes, &retSize);
gettimeofday(&tvEnd, NULL);
printf("Found %d combinations for target %d\n", retSize, T);
int ds = tvEnd.tv_sec - tvStart.tv_sec;
int dus = tvEnd.tv_usec - tvStart.tv_usec;
if (dus < 0) {
ds--;
dus += 1000000;
}
DBG("Time %d.%06d, combinationSum\n", ds, dus);
return 0;
}
int main() {
int candidates[] = { 2, 3, 6, 7 };
int target = 7;
int returnSize;
int *columnSize;
int **ans = combinationSum(candidates, sizeof(candidates) / sizeof(int), target, &columnSize, &returnSize);
int i, j;
for (i = 0; i < returnSize; ++i) {
for (j = 0; j < columnSize[i]; ++j) {
printf("%d ", ans[i][j]);
}
printf("\n");
}
system("pause");
return 0;
}
void combinationSum(vector<int> &candidates, int target, int idx, vector<int> &path, vector<vector<int>> &ret)
{
if (target == 0)
{
ret.push_back(path);
return;
}
for (int i = idx; i < candidates.size(); ++i)
{
if (target - candidates[i] < 0) break;
path.push_back(candidates[i]);
combinationSum(candidates, target - candidates[i], i, path, ret);
path.pop_back();
}
}
void combinationSum(const vector<int> &candidates,
int begin, int target, vector<int>& prefix) {
for (int i = begin; i < candidates.size(); ++i) {
int v = candidates[i];
if (v == target) {
result.push_back(prefix);
result.back().push_back(v);
} else if (v < target) {
prefix.push_back(v);
combinationSum(candidates, i, target - v, prefix);
prefix.pop_back();
} else {
break;
}
}
}
int main() {
int* returnSize; int** columnSizes = (int**) malloc(sizeof(int*)); int* candidates;
int candidatesSize, target;
scanf("%d%d", &candidatesSize, &target);
candidates = (int*) malloc(candidatesSize*sizeof(int));
int i; for (i = 0; i < candidatesSize; i++)
scanf("%d", &candidates[i]);
int** ans = combinationSum(candidates, candidatesSize, target, columnSizes, returnSize);
int j; for (i = 0; i < *returnSize; i++) {
for (j = 0; j < (*columnSizes)[i]; j++)
printf("%d ", ans[i][j]);
printf("\n");
free(ans[i]);
}
free(*columnSizes);
return 0;
}
vector<vector<int>> combinationSum(int k, int n, int num) {
vector<vector<int>> res;
if (k == 1 && num <= n) {
if (n <= 9) {
vector<int> tmp = {n};
res.push_back(tmp);
}
return res;
}
bool flag = (2 * num + k - 1) * k <= 2 * n ? true : false;
while (flag) {
vector<vector<int>> tmp = combinationSum(k - 1, n - num, num + 1);
for (int i = 0; i < tmp.size(); i++) {
tmp[i].insert(tmp[i].begin(), num);
res.push_back(tmp[i]);
}
num++;
flag = (2 * num + k - 1) * k <= 2 * n ? true : false;
}
return res;
}
void combinationSum(vector<int> &candidates, int index, int target, vector<vector<int> > &result) {
if(target <= 0)
return;
while(index<candidates.size() && target>=candidates[index]) {
for(int i=1; candidates[index]*i<=target; ++i) {
vector<int> pre(i, candidates[index]);
vector<vector<int> > res;
if(target == candidates[index]*i) {
result.push_back(pre);
} else {
combinationSum(candidates, index+1, target-candidates[index]*i, res);
for(int j=0; j<res.size(); ++j) {
vector<int> item = pre;
item.insert(item.end(), res[j].begin(), res[j].end());
result.push_back(item);
}
}
}
++index;
}
}
vector<vector<int> > combinationSum(vector<int> &ca, int ta) {
vector<vector<int> >ans;
if (ta == 0) {
vector<int> t;
ans.push_back(t);
return ans;
}
sort(ca.begin(), ca.end());
for (int i = 0; i * ca[0] <= ta; i++) {
vector<int> temp(ca.begin() + 1, ca.end());
if (temp.size() == 0 && ta - i * ca[0])
continue;
vector<vector<int> > x = combinationSum(temp, ta - i * ca[0]);
int su = x.size();
for (int j = 0; j < su; j++) {
vector<int> y(i, ca[0]);
copy(x[j].begin(), x[j].end(), back_inserter(y));
ans.push_back(y);
}
}
return ans;
}
void combinationSum(vector<int> &candidates, int index, int target, vector<vector<int> > &result) {
int n = candidates.size();
if(index>=n) {
return;
}
while(index<candidates.size() && target>=candidates[index]) {
vector<int> item;
for(int i=1; target>=candidates[index]*i; ++i) {
item.push_back(candidates[index]);
if(target == candidates[index]*i) {
result.push_back(item);
} else if(index+1<n) {
vector<vector<int> > res;
combinationSum(candidates, index+1, target-candidates[index]*i, res);
for(int j=0; j<res.size(); ++j) {
vector<int> i2 = item;
i2.insert(i2.end(), res[j].begin(), res[j].end());
result.push_back(i2);
}
}
}
++index;
}
}
vector<vector<int>> combinationSum3(int k, int n) {
vector<vector<int>> res;
vector<int> cur;
combinationSum(res, cur, k, n, 1);
return res;
}
