查找x ^ n的所有组合，并检查它们加起来是否等于一个数字，但不包括相同的数字

Question

So I was looking for a program which goes through all combinations of indices of an array and checks if there are corresponding numbers in the array which add up to a specific number (eg with 2 indices: array[0 to 10] + array[1 to 10] == number ? ). It should exclude combinations with the same index and preferably also combinations with just an other order (eg only 1,2 and not 2,1). When it finds such a combination it should save the right indices. My solution would be to do it with for-loops, but then I would have to create a new for-loop for each additional index which would be very tedious for approx. 40 indices. Here is an example in C++:

//3 indices
for (int i = 0; i < iter - 2 && canWork == false; i++) {
    for (int k = i + 1; k < iter - 1 && canWork == false; k++) {
        for (int l = k + 1; l < iter && canWork == false; l++) {
            if (sizes[i] + sizes[k] + sizes[l] == number) {
                indices[0] = i;
                indices[1] = k;
                indices[2] = l;
                canWork = true;
            }
        }
    }
}

//4 indices
for (int i = 0; i < sizeArray - 3 && canWork == false; i++) {
    for (int k = i + 1; k < sizeArray - 2 && canWork == false; k++) {
        for (int l = k + 1; l < sizeArray -1 && canWork == false; l++) {
            for (int m = l + 1; m < sizeArray && canWork == false; m++) {
                if (array[i] + array[k] + array[l] + array[m] == number) {
                    indices[0] = i;
                    indices[1] = k;
                    indices[2] = l;
                    indices[3] = m;
                    canWork = true;
                }
            }
        }
    }
}

The - 2 and -1 after the sizeArray and the start with + 1 serves to skip same sums. I am a very beginner programmer, so please forgive me if the code is that bad. I also could not find anything regarding this problem, so I am asking here.

Answer 1

As I had already hinted at in my comment to your question, the easiest way to solve this problem is by using what is known as dynamic programming .

The idea is to find a relation between the problem when searching for n indices and the problem when searching for n + 1 indices.

In this particular case, we can reduce the case of n + 1 indices to the case of n indices by using the following observations:

• There are two possibilities: Either a combination of n + 1 indices that satisfies the constraints uses the very last index of the array, or it doesn't. In the first case we can find a combination of n + 1 indices that sum to number by searching for n indices in the array up to but excluding the last element that sum to number - v where v is the value of the last element in the array. If we can't find such a combination (ie we're in the second case) then we can try again to search for n + 1 indices in the array without the last element.
• There is no combination of n indices that sum to number if the array has less than n elements.
• The case of n = 1 is trivial: We just have to walk through the array once and see if we can find one value that is equal to the number we're looking for.

A straight forward implementation of these observations can look like this:

#include <algorithm>
#include <iterator>
#include <vector>

/**
 * returns the `number_of_indices` indices of `input_array` for which 
 * the corresponding elements sum to `sum`, or an empty vector if
 * there is no such combination of indices.
 */
std::vector<std::int64_t> find_n_indices_that_sum_to(std::vector<int> input_array, 
                                                     int number_of_indices,
                                                     int sum)
{
    if (number_of_indices == 1)
    {
        // the trivial case, just search for one element equal to `sum`.
        auto const match = std::find(std::cbegin(input_array),
                                     std::cend(input_array),
                                     sum);

        return match != std::cend(input_array) 
            ? std::vector<std::int64_t>{std::distance(std::cbegin(input_array), match)}
            : std::vector<std::int64_t>{};
    } else if (static_cast<std::size_t>(number_of_indices) > std::size(input_array)) {
        // not enough elements to find the required number of indices
        return std::vector<std::int64_t>{};
    } else {
        auto const last_index = std::size(input_array) - 1;
        auto const value = input_array.back();

        // reduce the size of the array by 1 - either we find
        // `number_of_indices - 1` additional indices that sum to 
        // `sum - value` or we're in case 2 described above and try 
        // to find `number_of_indices` indices in the smaller array
        input_array.pop_back();

        auto indices = find_n_indices_that_sum_to(input_array,
                                                  number_of_indices - 1, 
                                                  sum - value);
        if (!indices.empty()) {
            // case 1 - there is a combination of indices whose corresponding
            //          elements sum to `sum` with one of them being the
            //          very last index of the array
            indices.push_back(last_index);

            return indices;                 
        } else {
            // case 2 - we try again in the smaller array
            return find_n_indices_that_sum_to(input_array,
                                              number_of_indices,
                                              sum);
        }
    }
}

You can also try this solution on wandbox .

If you like you can also try to improve the performance of this solution, eg by replacing the input_array vector argument by a gsl::span to avoid copies or by making the function tail-recursive or even fully imperative in order to avoid stack overflows for large number_of_indices .