防止递归组合生成中的内存分配

Question

（对不起，标题不是最好的描述）

我正在玩图论，并生成一组给定输入数字的所有可能组合。给定输入集 {2,3,4}，我可能的组合（其中有3!）是：

以下递归解决方案有效，但我不喜欢我必须“复制”输入向量以“删除”代表我正在关注的节点的元素以防止将其包含在输出中的事实再次。我要输出的元素存储在vecValues，而我当前可以选择的元素存储在vecInput：

void OutputCombos(vector<int>& vecInput, vector<int>& vecValues)
{
    // When hit 0 input size, output.
    if (vecInput.size() == 0)
    {
        for (int i : vecValues) cout << i << " ";
        cout << endl;
    }
    size_t nSize = vecInput.size();
    for (vector<int>::iterator iter = begin(vecInput); iter != end(vecInput); ++iter)
    {
        auto vecCopy = vecInput;
        vecCopy.erase(find(begin(vecCopy), end(vecCopy), *iter));
        vecValues.push_back(*iter);
        OutputCombos(vecCopy, vecValues);
        vecValues.pop_back();
    }
}

void OutputCombos(vector<int>& vecInput)
{
    vector<int> vecValues;
    OutputCombos(vecInput, vecValues);
}

int main()
{
    vector<int> vecInput{ 2,3,4 };
    OutputCombos(vecInput);
    return 0;
}

正如我的状态空间树所期望的那样，输出是

2 3 4 2 4 3 3 2 4 3 4 2 4 2 3 4 3 2

请问如何在不必为每个递归调用复制向量的情况下解决这个问题？

Answer 1

您总是可以只使用来自<algorithm> 的std::next_permutation

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

int main()
{
  std::vector<int> input {2, 3, 4};

  do {
        for (auto i : input) std::cout << i << " ";
        std::cout << std::endl;
     }  while(std::next_permutation(input.begin(), input.end()));

    return 0;
}

这会为您提供相同的输出。您可能想查看 next_permutation 的 a possible implementation，它涉及向量内的交换，而不是多次复制向量。

Answer 2

我认为这可能更接近您正在寻找的内容。没有std::next_permutation 的版本不涉及复制任何向量，并允许输入保持const。但是，这样做的代价是在每次迭代中检查输出，以确保它不会两次添加相同的数字。

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

template<typename T>
void OutputCombinations(
    const std::vector<T>& input,
    std::vector<typename std::vector<T>::const_iterator >& output)
{
  for(auto it = input.begin(); it != input.end(); ++it)
  {
    if (std::find(output.begin(), output.end(), it) == output.end())
    {
      output.push_back(it);
      if (output.size() == input.size())
      {
        for(auto node : output) std::cout << *node << " "; 
        std::cout << std::endl;
      }
      else OutputCombinations(input, output);

      output.pop_back();
    }
  }
}

int main()
{
  std::vector<int> nodes{ 2, 3, 4, 2 };
  std::vector<std::vector<int>::const_iterator> result{};
  OutputCombinations(nodes, result);

  return 0;
}

Answer 3

经过大量学习，我在this article 中找到了灵感，这给了我最终的解决方案。这个想法是我们保留一个由Boolean 值组成的向量，它指示组合中是否使用了特定值；这样我们就不需要删除我们已经使用过的元素，因此没有内存分配开销。

所以，在构建分支{2,4,3} 时，如果我们到达{2,4}，vecTaken 将是{true, false, true} 和nNumBoolsSet 将是2。所以当我们循环时，我们只会“使用”该元素在 vecInput 的索引 1 处，因为这是唯一没有按照 vecTaken 的指示使用的元素。

void OutputCombos(vector<int>& vecInput, vector<int>& vecValues, vector<bool>& vecTaken, int& nNumBoolsSet)
{
    size_t nSize = vecInput.size();
    if (nNumBoolsSet == nSize)
    {
        for (int i : vecValues) cout << i << " ";
        cout << endl;
        return;
    }
    for (vector<int>::size_type i = 0; i < nSize; ++i)
    {
        if (vecTaken[i] == false)
        {
            vecValues.push_back(vecInput[i]);
            vecTaken[i] = true;
            ++nNumBoolsSet;
            OutputCombos(vecInput, vecValues, vecTaken, nNumBoolsSet);
            vecTaken[i] = false;
            vecValues.pop_back();
            --nNumBoolsSet;
        }
    }
}

void OutputCombos(vector<int>& vecInput)
{
    vector<int> vecValues;
    vector<bool> vecTaken(vecInput.size(), false);
    int nNumBoolsSet = 0;
    OutputCombos(vecInput, vecValues, vecTaken, nNumBoolsSet);
}

int main()
{
    vector<int> vecInput{ 2,3,4 };
    OutputCombos(vecInput);
}