int main(void)
{
int **res, n, *col;
res = combinationSum3(3, 28, &col, &n);
return(0);
}
vector<vector<int>> combinationSum3(int k, int n)
{
vector<int> path;
vector<vector<int>> ret;
combinationSum3(1, k, n, path, ret);
return ret;
}
int main(void)
{
int **res, n, i, *col;
res = combinationSum3(3, 9, &col, &n);
for (i = 0; i < n; i++)
printf("%d %d %d\n", res[i][0], res[i][1], res[i][2]);
return(0);
}
vector<vector<int>> combinationSum3(int k, int n) {
if(!k)
return result;
vector<int> tempRes;
tempRes.reserve(k);
combinationSum3(1, k, n, tempRes, 0);
return result;
}
void combinationSum3(int idx, int k, int target, vector<int>& v, vector<vector<int>>& result){
if (!k){
if (!target)
result.push_back(v);
return;
}
for (int i = idx; i <= 9 && i <= target; i++){
v.push_back(i);
combinationSum3(i + 1, k - 1, target - i, v, result);
v.pop_back();
}
}
void combinationSum3(vector<vector<int>> &res, vector<int> &sol, int k, int n) {
if(sol.size() == k && n == 0) {
res.push_back(sol);
}
else {
for(int i= sol.empty()?1:sol.back()+1; i<=n && i <= 9; i++) {
sol.push_back(i);
combinationSum3(res, sol, k, n-i);
sol.pop_back();
}
}
}
void combinationSum3(const int k, const int n, int pathSum, vector<int> &path,
vector<vector<int>> &result) {
if (path.size() == k && pathSum == n) {
result.emplace_back(path);
} else if (path.size() < k && pathSum < n) {
int start = path.empty() ? 1 : path.back() + 1;
for (int idx = start; idx <= 9; ++idx) {
path.emplace_back(idx);
combinationSum3(k, n, pathSum + idx, path, result);
path.pop_back();
}
}
}
void combinationSum3(int cur, int k, int n, vector<int> &path, vector<vector<int>> &ret)
{
if (n == 0 && k == 0)
{
ret.push_back(path);
return;
}
for (int i = cur; i < 10; ++i)
{
if (n - i < 0) break;
path.push_back(i);
combinationSum3(i + 1, k - 1, n - i, path, ret);
path.pop_back();
}
}
void combinationSum3(int k, int target, int s, vector<int> path, vector<vector<int>> &res) {
if (k < 0) return;
if (k == 0) {
if (target == 0) {
res.push_back(path);
}
return;
}
if (target < s) return;
for (int i = s; i < 10; i++) {
path.push_back(i);
combinationSum3(k-1, target-i, i+1, path, res);
path.pop_back();
}
}
void combinationSum3(int target, std::vector<std::vector<int> > &res, std::vector<int> &combination, int begin, int need) {
// okay , target == 0
if (!target) {
res.push_back(combination);
return;
}
else if (!need) // need == 0 , end
return;
// i + i+1 + ... + i+need-1
for (int i = begin; i < 10 && target >= need * (2*i + need - 1) / 2; ++i) {
combination.push_back(i);
combinationSum3(target - i, res, combination, i + 1, need - 1);
combination.pop_back();
}
}
void combinationSum3(int num, int k, int n, vector<int>& tempRes, int sum)
{
if(k == 0 && sum == n)
{
result.push_back(tempRes);
return;
}
for(int i = num; i < 10; i++)
{
if(i + sum <= n && k)
{
tempRes.push_back(i);
combinationSum3(i+1, k-1, n, tempRes, sum+i);
tempRes.pop_back();
}
else
return;
}
}
vector<vector<int>> combinationSum3(int k, int n) {
vector<vector<int>> res;
vector<int> sol;
combinationSum3(res, sol, k, n);
return res;
}
vector<vector<int>> combinationSum3(int k, int n) {
vector<int> path;
vector<vector<int>> result;
combinationSum3(k, n, 0, path, result);
return move(result);
}
vector<vector<int>> combinationSum3(int k, int n) {
vector<int> path;
vector<vector<int>> res;
combinationSum3(k, n, 1, path, res);
return res;
}
vector<vector<int>> combinationSum3(int k, int n) {
vector<vector<int>> result;
vector<int> v;
combinationSum3(1, k, n, v, result);
return result;
}
std::vector<std::vector<int> > combinationSum3(int k, int n) {
std::vector<std::vector<int> > res;
std::vector<int> combination;
combinationSum3(n, res, combination, 1, k);
return res;
}
#include "Catch/single_include/catch.hpp"
#include "CombinationSum3.hpp"
TEST_CASE("Combination Sum 3") {
std::vector<std::vector<int>> result{{1, 2, 6},
{1, 3, 5},
{2, 3, 4}};
auto ret = combinationSum3(3, 9);
REQUIRE(ret == result);
}
