Question

我有3个数组，我需要得到这3个数组的总和。这是我的阵列
[37,9,7]
[42,50,2]
[57,92,52]
我需要找到所有可能的解决方案而不重复。在这种情况下，我需要找到6个解决方案，即 37 + 50 + 52,9 + 2 + 57,7 + 50 + 57,9 + 42 + 52,37 + 92 + 2,7 + 42 + 92

这是我的代码：

#include <iostream>

using namespace std;

int main()
{
    int arr[3] = { 37, 9, 7 };
    int arr1[3] = { 42, 50, 2 };
    int arr2[3] = { 57, 92, 52 };
    int arr3[3] = {};

    for (int i = 0; i < 3; i++)
        for (int j = 0; j < 3; j++)
            for (int k = 0; k < 3; k++)
            {
                if (i != j && i!= k && j !=k)
                    arr3[i] = arr[i] + arr1[j] + arr2[k];
            }

    cout << "The sum is " << endl;
    for (int i = 0; i < 6; i++)
    {
        cout << arr3[i] << " " << endl;
    }

    return 0;
}

结果只有前三个解决方案正确，其余的都是错误的我的结果：

The sum is
131
68
114
-858993460
-858993460
57

Answer 1

int arr3[3] = {};意味着拥有所有解决方案，但只有3个元素。您只需设置这3个元素。

也许您应该将大小增加到预期的解决方案数量，并为arr3保留一个单独的计数器 - 因为i只会从0变为2。

实际代码留作练习。

Answer 2

@ Luchian的答案是正确而且重点。但是，即使您是初学者，也应该尝试学习现代C ++。不幸的是，大多数教师/教师将其视为“高级主题”，而不应该如此。编写现代C ++意味着（大部分时间）充分利用标准库。大多数情况下，您的代码会更安全。这就是我使用标准库中的容器和算法的方法：

#include <iostream>
#include <algorithm>
#include <string>

int main()
{
    const std::size_t N = 3; // number of arrays
    std::vector<std::vector<int>> arrays;

    arrays.push_back({ 37, 9, 7 }); // first array
    arrays.push_back({ 42, 50, 2 }); // second array
    arrays.push_back({ 57, 92, 52 }); // third array

    std::vector<int> result; // here we store the results

    std::vector<std::size_t> perm(N);
    // fill in the vector with 0 ... N-1, which we'll later permute
    std::iota(perm.begin(), perm.end(), 0); 
    do { // loop over all permutations
        int sum = 0;
        for (std::size_t i = 0; i < perm.size(); ++i)
            sum += arrays[i][perm[i]];
        result.push_back(sum);
    } while (std::next_permutation(perm.begin(), perm.end()));

    // display the result
    std::cout << "The possible sums are: " << std::endl;
    for(auto elem: result)
        std::cout << elem << " ";
}

此解决方案将复杂性从N^N降低到N!，并且还可以扩展。

修改

正如@Bathsheba在下面的评论中所提到的，如果你想成为超级安全的，那么你应该再次防范循环中int的溢出。有多种方法可以做到这一点，例如使用unsigned int，如果你知道你的元素是积极的。 unsigned类型永远不会溢出，它们会绕过最大值，因此，在最坏的情况下，您最终会“重置”您的总和。

在c ++的3个数组中找到所有可能的解决方案而不重复

2 个答案: