是否可以编写像 next_permutation 这样的函数，但只置换 r 值而不是 n？

Question

std::next_permutation（和std::prev_permutation）置换[first, last)范围内的所有值，总共n！排列（假设所有元素都是唯一的）。

可以这样写函数吗：

template<class Iter>
bool next_permutation(Iter first, Iter last, Iter choice_last);

这会置换[first, last) 范围内的元素，但只选择[first, choice_last) 范围内的元素。即我们可能有 20 个元素，并且想要遍历其中 10 个选项的所有排列，20 P 10 个选项与 20 P 20 个选项。

• Iter 对我来说是一个随机访问迭代器，但如果它可以实现为双向迭代器，那就太好了！
• 所需的外部内存越少越好，但对我而言这并不重要。
• 每次迭代中选择的元素都会输入到序列的第一个元素中。

这样的功能可以实现吗？有谁知道任何现有的实现？

这基本上就是我正在做的事情来解决这个问题。也欢迎就如何改进这一点提出建议。

• 从N 元素的向量V 开始，我想访问其中选择的R 元素的每个排列(R <= N)。
• 用值{ 0, 1, 2, ... R - 1 } 构建一个长度为R 的向量I，作为V 元素的索引
• 在每次迭代中，构建一个长度为R 的向量C，其值为{ V[I[0]], V[I[1]], ... V[I[R - 1]] }
• 使用C 中的值做一些事情。
• 应用一个函数来置换I 的元素，如果可以的话再次迭代。

该函数如下所示：

bool NextPermutationIndices(std::vector<int> &I, int N)
{
    const int R = I.size();
    for (int i = R - 1; ; --i) {
        if (I[i] < N - R + i) {
            ++I[i];
            return true;
        }

        if (i == 0)
            return false;

        if (I[i] > I[i-1] + 1) {
            ++I[i-1];
            for (int j = i; j < R; ++j)
                I[j] = I[j-1] + 1;
            return true;
        }
    }
}

由于所有可能的错误，该函数非常复杂，而且使用它的所有内容都比可能需要的复杂。

---

编辑：

事实证明，这比我想象的要容易明显。从here，我能够找到许多我需要的精确算法（组合、排列等）的精确实现。

template<class BidirectionalIterator>
bool next_partial_permutation(BidirectionalIterator first,
                              BidirectionalIterator middle,
                              BidirectionalIterator last)
{
    std::reverse(middle, last);
    return std::next_permutation(first, last);
}

此外，还有一种以类似方式工作的组合算法。但是，实现起来要复杂得多。

Answer 1

不管它的价值，这是一个可行的实现。

它要求上面选择的元素以排序顺序开始。它仅在序列中没有重复元素时才有效（如果有，它会丢失一些排列，并且不会以正确的排列结束）。它也可能缺少一些边缘情况，因为我没有真正彻底测试它，因为我没有实际使用它的计划。

这种方式优于this answer's 的一个好处是，这种方式不会按字典顺序访问排列，这可能（但可能不）很重要。有时使用 boost::bind 创建一个函子来传递给 for_each 也是一种痛苦。

template<class Iter>
bool next_choice_permutation(Iter first, Iter choice, Iter last)
{
    if (first == choice)
        return false;

    Iter i = choice;
    --i;
    if (*i < *choice) {
        std::rotate(i, choice, last);
        return true;
    }

    while (i != first) {
        Iter j = i;
        ++j;
        std::rotate(i, j, last);
        --i;
        --j;
        for (; j != last; ++j) {
            if (*i < *j)
                break;
        }
        if (j != last) {
            std::iter_swap(i, j);
            return true;
        }
    }
    std::rotate(first, ++Iter(first), last);
    return false;
}

Answer 2

算法简化是将其分成两个单独的步骤。

• 从原始数据中生成所有可能的 R 元素选择列表。
• 对于每个选择，创建所选元素的所有可能排列。

通过交错这些操作，您可以避免分配中间列表。

可以通过跳过未选择的项目在双向迭代器上实现选择。生成所有选择，例如通过置换R 1 和(N-R) 0 的序列。这将需要 O(N) 额外的内存，但使您能够就地置换原始序列。

Answer 3

为了迭代 nPk 排列，我之前使用了 this old CUJ article 中提供的 for_each_permutation() 算法。它使用了来自 Knuth 的一个很好的算法，它在原地旋转元素，最后让它们保持原来的顺序。因此，它满足您的无外部存储器要求。它也适用于双向迭代器。它不符合您看起来像next_permutation() 的要求。但是，我认为这是一个胜利——我不喜欢有状态的 API。

Answer 4

Java 组合生成器的源代码位于 http://www.merriampark.com/comb.htm。去掉 Java 惯用语，它几乎就是您要寻找的东西，它被实现为一个生成器，以限制您的内存使用。

---

这个问题来自称为组合数学的数学领域，它是离散数学的一部分。离散数学对计算机科学从业者来说至关重要，因为它几乎涵盖了我们日常使用的所有数学（如逻辑、算法、计数、关系、图论等）。我强烈推荐Discrete and Combinatorial Mathematics: An applied introduction 或 Discrete Mathematics and Its Applications，如果你负担得起的话。

（注意：这个问题与“Algorithm for Grouping”有关，但并不完全重复，因为这个问题要求在一般情况下解决它。）