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; }