递归地确定数组中的元素是否可以求和 - C ++

Question

I am doing practice with recursion and trying small problems. One of the functions I am trying to design comboSum takes in an array of integers, its size, and a target value. It returns true if a combination of any of the elements (can only use each element once) adds to the target value. This is my implementation so far.

// Expected Behaviors
// comboSum([1, 2, 3], 3, 0) => false
// comboSum([2, 4, 8], 3, 12) => true
// comboSum([2, 4, 8], 3, 11) => false
// comboSum([], 0, 0) => true

bool comboSum(const int a[], int size, int target)
{
    if (target == 0)
        return true; // if we have decremented target to zero
    if (target != 0 && size == 0)
        return false; // if we havent hit target to zero and we have no more elements

    size--;

    return (comboSum(a, size, target) || comboSum(a, size, target - a[size]));

    // OR logic ensures that even if just one sum exists, this returns true
}

My algorithm works except for the case of an array with all non-zero values and the target being zero. The function immediately returns true without checking for a valid summation.

// comboSum({1, 2, 3}, 3, 0) returns true when this should be false

What are some possible ways to correct this issue?

Edit: I cannot change the parameters or call any additional helper functions. The function header must remain as is and I must solve the problem recursively (no use of for or while loops or STL algorithms)

Answer 1

A simple solution is to keep the size parameter fixed and have another parameter that indicates the current position of the recursion.

bool comboSum(const int *a, int size, int pos, int target) {
    if (target == 0)
        return pos < size || size == 0; // true if pos has moved or if the array is empty
    else if (pos == 0)
        return false;

    pos--;
    return comboSum(a, size, pos, target) || comboSum(a, size, pos, target - a[pos]);
}

This solution handles your test cases correctly, but we have to pass the pos argument after the size argument. Both arguments should start with the same value:

// comboSum([1, 2, 3], 3, 3, 0) => false
// comboSum([2, 4, 8], 3, 3, 12) => true
// comboSum([2, 4, 8], 3, 3, 11) => false
// comboSum([], 0, 0, 0) => true

C++ in Practice

Since this question is tagged as C++, it would be a good idea to use a class that gives us more flexibility than C arrays. For example, we could use a std::vector . If that's the case, then we don't need an extra parameter for the size of the list:

#include <vector>

bool comboSum(std::vector<int>& v, size_t pos, int target)
{
    if (target == 0) {
        return pos < v.size() || v.size() == 0;
    } else if (pos == 0) {
        return false;
    }
    pos--;
    return comboSum(v, pos, target) || comboSum(v, size, target - v[pos]);
}

Answer 2

If you want to keep everything you have as-is, try adding a variable to count the number of recursions.

bool comboSum(const int a[], int size, int target, int count = 0)
{
    if (target == 0 && size == 0 && count == 0)
        return false;
    else if (target == 0)
       return true;
    else if (target != 0 && size == 0)
       return false;

size--;

return (comboSum(a, size, target) || comboSum(a, size, target - a[size]));
};

Please note that there are definitely better ways to do this, but as a learning exercise it doesn't hurt to give this a go!