Question

假设我有一个给定的总和，比如说 sum = 4。我还得到了一个向量 = {2,4}。有两种方法可以从给定的向量（元素可以重用）生成给定的总和。一种方法是 {4} 导致 4 = 4。第二种方式是 {2,2} 导致 2 + 2 = 4。我必须找到尽可能短的组合，因此在这种特殊情况下，答案是 {4}。

这是我的方法 - 我遍历树，当在叶子上得到 0 时，我们找到基本情况，返回 {} 向量，并在遍历树时填充向量。当我到达一个节点时，我选择两个（或更多）向量中较小的一个。这样当我到达根节点时，我应该得到一个最短组合的向量，它可以产生目标总和。

到目前为止，我并不关心时间限制，我知道有很多重复的计算正在进行，所以一旦我得到基本版本正确，我将不得不记住它。

我一直在试图弄清楚为什么这段代码不起作用。任何见解将不胜感激。

#include <vector>
#include <algorithm>
#include <iostream>

using namespace std;

vector<int> findBestSum(int targetSum, const vector<int> &elements, vector<vector<int>> &temp) {
    if (targetSum == 0)
        return {};
    else if (targetSum < 0)
        return {-1};
    else {
        vector<int> small;
        for (auto &i : elements) {
            int remainder = targetSum - i;
            vector<int> returnedVector = findBestSum(remainder, elements, temp);
            if ((!returnedVector.empty() && find(returnedVector.begin(), returnedVector.end(), -1) == returnedVector.end()) || returnedVector.empty()) {
                returnedVector.push_back(i);
                temp.push_back(returnedVector);
            }
            int smallestLength = temp[0].size();
            for (auto &j : temp)
                if (smallestLength >= j.size())
                    small = j;
        }
        return small;
    }
}

int main() {
    int targetSum = 6;
    const vector<int> elements{2, 3, 5}; // answer should be [3,3] however I just get a 3...
    vector<vector<int>> temp;
    vector<int> bestSumVector = findBestSum(targetSum, elements, temp);
    for (auto i : bestSumVector)
        cout << i << " ";
}

Answer 1

我对此进行了尝试。我确实有一个可行的解决方案，希望这是您想要的：

#include <iostream>
#include <vector>
#include <algorithm>

void howSum(int targetSum, const std::vector<int> & elementVector, const std::vector<int> & howSumVector, std::vector<std::vector<int>> & allSums)
{
    static int originaltargetsum = targetSum;

    if (targetSum == 0)
    {
        allSums.push_back(howSumVector);
        return;
    }
    else if (targetSum < 0)
    {
        return;
    }
    else
    {
        for (const auto i : elementVector)
        {
            // an element less than or equal to 0 would cause an infinite loop
            if (i <= 0)
                continue;

            std::vector<int> newSumVector = howSumVector;
            newSumVector.push_back(i);

            std::vector<int> newElementVector;
            std::copy_if(std::begin(elementVector), std::end(elementVector), std::back_inserter(newElementVector), [i](int element){ return element >= i; });

            howSum(targetSum - i, newElementVector, newSumVector, allSums);
        }
    }
}

int main()
{
    int sum = 8;
    std::vector<int> elements = { 1, 4, 5 };
    std::vector<std::vector<int>> allSums = {};
    std::vector<int> workingBench = {};

    howSum(sum, elements, workingBench, allSums);

    for (const auto & i : allSums)
    {
        for (const auto & j : i)
        {
            std::cout << j << " ";
        }

        std::cout << std::endl;
    }

    return 0;
}

我认为，总的来说，您对问题的思考或设计过度了。就像其他人提到的那样，您当前的代码返回 true 过早，并且除了第一个元素/组合之外没有任何测试。对于递归，重要的是要注意您的返回案例 - 实际上，您只需要一两个基本案例，否则您想要重复。

对于我这里的解决方案，我添加的主要内容是为您需要测试的每个元素复制当前的元素组合。这解决了您不测试每个数字组合的主要问题。除此之外，当达到 allSums 时附加到 targetSum 似乎更好。通过这些更改，我能够取消 bool 返回值并稍微简化代码。运行上面的代码给出了以下解决方案：

1 1 1 1 1 1 1 1
1 1 1 1 4
1 1 1 4 1
1 1 1 5
1 1 4 1 1
1 1 5 1
1 4 1 1 1
1 5 1 1
4 1 1 1 1
4 4
5 1 1 1

这确实有一些重复（因为测试的顺序），但我觉得它已经足够好了，因为您只想要最小的解决方案，4 4。要找到这一点，您只需按内部向量大小对 allSums 向量进行排序，然后获取第一个条目。

Answer 2

我认为您需要更改实现以正确处理向量的元素。在您的实现中，它不会遍历所有向量项，而只是第一个。如果您使用向量元素作为函数中的第一个参数，这是一种方法。

vector<int> findBestSum(int element, int targetSum, const vector<int>& elements, 
vector<vector<int>>& temp) {
if (targetSum == 0)
    return {};
else if (targetSum < 0)
    return { -1 };
else {
    int remainder = targetSum - element;
    vector<int> returnedVector = findBestSum(element, remainder, elements, temp);
    if ((!returnedVector.empty() && find(returnedVector.begin(), returnedVector.end(), -1) == returnedVector.end()) || returnedVector.empty()) {
        returnedVector.push_back(element);
        return returnedVector;
    }
    return returnedVector;
}

}

int main() {
  const int targetSum = 6;
  const vector<int> elements{ 2, 3, 5 }; // answer should be [3,3] however I just get a 3...
  vector<vector<int>> temp;
  for (auto i : elements) {
      vector<int> returnedVector = findBestSum(i, targetSum, elements, temp);
      if ((!returnedVector.empty() && find(returnedVector.begin(), returnedVector.end(), -1) == returnedVector.end()) || returnedVector.empty())
          temp.push_back(returnedVector);
  }

  if (temp.size() > 0) {
      vector<int> bestSum = {};
      size_t small = 0;
      size_t smallestLength = temp[0].size();
      for (auto& j : temp)
          if (smallestLength >= j.size()) {
              small = j.size();
              bestSum = j;
          }
      for (auto i : bestSum)
          cout << i << " ";
    }
    else
        cout << " sum not found" << endl;
}

比较递归树分支的返回向量

2 个答案: