How do I recursively enumerate all subsets adding to a given sum?

Question

When I try to get the output, it shows same solutions with same element for few times before moving on to another one.

I want to get different solutions from the array that is equal to sum

For instance,

Solution 1 = 14, 8

Solution 2 = 14, 5, 3

Solution 3 = 13, 9

and so on but what I get is repeated solutions for the sum of 22. Im getting this error

Solution : { 14, 8 }

Solution : { 14, 8 }

Solution : { 14, 8 }

Solution : { 14, 8 }

Solution : { 14, 8 }

Solution : { 14, 8 }

Solution : { 14, 5, 3 }

Solution : { 13, 6, 3 }

Solution : { 13, 5, 4 }

Solution : { 13, 5, 4 }

Solution : { 13, 6, 3 }

Solution : { 13, 5, 4 }

Solution : { 13, 5, 4 }

and another 20 lines of the same output.

#include <iostream>
#include <cstdlib>
#include <iomanip>
#include <vector>
#include <algorithm>


using namespace std;




void printSolution(int* r, int k)
{
    cout << " Solution : { ";
    for (int j = 0; j < k; j++)
        {
        cout << r[j]; 

        if (j < k - 1)
            cout << ", ";


    }

    cout << " }" << endl;

}

bool subSetSum(int* a, int n, int i, int sum, int* r, int k)
{
    if (sum == 0)
        printSolution(r, k);
    if (i > n)
        return false;

    r[k++] = a[i];

    if (subSetSum(a, n, i + 1, sum - a[i], r, k))
        return true;

    k -= 1;
    subSetSum(a, n, i + 1, sum, r, k);

}

int descendingOrder(const void* a, const void* b)
{
    int* p1 = (int*)a;
    int* p2 = (int*)b;
    return *p2 - *p1;
}

int main()
{
    int a[] = { 4, 10, 7, 12, 6, 10, 10, 8, 5, 13, 13, 11, 3, 14 };
    int n = 14;

    int* r = new int[n];
    int k = 0;


    qsort(a, n, sizeof(int), descendingOrder);

    cout << " Array a[] = ";

    for (int count = 0; count < n; count++)
    {
    cout << a[count] << "  ";
    }

    cout << endl << endl;
    int sum = 22;

    bool solFound = subSetSum(a, n, 0, sum, r, k);

    return 0;
}

Answer 1

You have several errors in your subsetSum function. First of all, your version has a branch where it doesn't return a value. This could have been easily mitigated by enabling compiler warnings.

Second, you have an off-by-one error in your termination condition. i==n is an invalid index, so you will run-over your buffer end.

The reason you get the same result several times is because there are multiple paths to the same result. This is most likely related to the missing return statement.

The fix for this is to terminate the recursion descend once you find a match (when you print it). It is guaranteed that you will not find additional results (unless there are entries <= 0 in your input).

bool subSetSum(int* a, int n, int i, int sum, int* r, int k)
{
    if (sum == 0) {
        printSolution(r, k);
        return true;
    }
    if (i >= n)
        return false;

    r[k] = a[i];

    bool found = subSetSum(a, n, i + 1, sum - a[i], r, k + 1);

    found = subSetSum(a, n, i + 1, sum, r, k) || found;

    return found;
}

Please note that this still finds duplicate solutions for duplicate values in your input array (such as 10). You can easily add a check to skip duplicate values in the second recursion call to subSetSum by not passing i + 1 but by finding the next index that is not duplicate. Since you already sorted your input, this can be done by incrementing i until it points to a different value.

---

Also it should be pointed out that this is quite unidiomatic C++. A better interface to your subsetSum would look like this:

template <typename T, typename ConstIterator>
bool subSetSum(ConstIterator begin, ConstIterator end, T sum, std::vector<T>& buf);

template <typename T, typename ConstIterator>
bool subSetSum(ConstIterator begin, ConstIterator end, T sum) {
  std::vector<T> buf;
  return subSetSum(begin,end,std::move(T),buf);
}

Answer 2

First of all, no effeciency can be applied here (probably), since this question is NP complete, which means it is probably not solvable in polynomial time.

About the solution, I'll attach a code:

using SolutionT = std::vector<std::set<std::size_t>>;

SolutionT subsetSum(const std::vector<int>& array, int requiredSum, std::size_t index, int currentSum)
{
    if (currentSum > requiredSum) { // Remove it if negative integers are present
        return {};
    }

    if (index >= array.size()) {
        return {};
    }

    if (requiredSum == currentSum + array[index]) {
        std::set<std::size_t> indices{};
        indices.insert(index);
        SolutionT solution;
        solution.emplace_back(std::move(indices));
        return solution;
    }

    auto includedSolutions = subsetSum(array, requiredSum, index + 1, currentSum + array[index]);
    for (auto& solution : includedSolutions) {
        solution.insert(index);
    }

    auto excludedSolutions = subsetSum(array, requiredSum, index + 1, currentSum);

    std::copy(std::make_move_iterator(includedSolutions.begin()),
              std::make_move_iterator(includedSolutions.end()), 
              std::back_inserter(excludedSolutions));
    return excludedSolutions;
}

SolutionT subsetSum(const std::vector<int>& array, int requiredSum)
{
    return subsetSum(array, requiredSum, 0, 0);
}

The code is rather complicated since you need an exponential number of elements, so it is very hard to do without C++ containers.