Question

我想构建一个C ++程序，根据N因子采用的元素数量显示所有可能的组合。

让我们假设一个矢量vec [6]上有元素1 2 3 4 5 6 使用组合配方，6！ / 4！（6 - 4）！ = 15种可能性
我想生成一个函数，它给出了4乘4的所有可能性的结果，没有重复，例如：
1 2 3 4
1 2 3 5
1 2 3 6
2 3 4 5
等等...

我现在正在使用此代码，但我想使用矢量中的数字（v [6]）。

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

void comb(int N, int K)
{
    std::string bitmask(K, 1); // K leading 1's
    bitmask.resize(N, 0); // N-K trailing 0's

    // print integers and permute bitmask
    do {
        for (int i = 0; i < N; ++i) // [0..N-1] integers
        {
            if (bitmask[i]) std::cout << " " << i;
        }
        std::cout << std::endl;
    } while (std::prev_permutation(bitmask.begin(), bitmask.end()));
}

int main()
{
    comb(6, 4);
}

你愿意帮我们帮忙吗？我想知道我可以在哪里更改代码，以便我可以使用自己的矢量。

我正在生成此向量v [i]并使用冒泡排序对其进行排序，如下所示：

void order (int d[], int n){
    int i, j;
    for (i = 1; i < n; i++)
        for (j = 0; j < n-1; j++)
            if (d[j] > d[j+1])
                swap (d[j],d[j+1]);

    for (i = 0; i < n; i++)
        cout << d[i] << " ";
}

在排序之后，我想把我的矢量放到梳子函数中。我怎么能做到这一点？

Answer 1

这是一个使用free, open source library来完成工作的C ++ 14解决方案：

#include "combinations"
#include <iomanip>
#include <iostream>
#include <vector>

int
main()
{
    std::vector<int> v{1, 2, 3, 4, 5, 6};
    int state = 0;
    for_each_combination(v.begin(), v.begin() + 4, v.end(),
        [&state](auto first, auto last)
        {
            std::cout << std::setw(2) << ++state << " : ";
            while (true)
            {
                std::cout << *first;
                if (++first == last)
                    break;
                std::cout << ' ';
            }
            std::cout << '\n';
            return false;
        });
}

输出：

 1 : 1 2 3 4
 2 : 1 2 3 5
 3 : 1 2 3 6
 4 : 1 2 4 5
 5 : 1 2 4 6
 6 : 1 2 5 6
 7 : 1 3 4 5
 8 : 1 3 4 6
 9 : 1 3 5 6
10 : 1 4 5 6
11 : 2 3 4 5
12 : 2 3 4 6
13 : 2 3 5 6
14 : 2 4 5 6
15 : 3 4 5 6

可以从上面的链接复制/粘贴库的源代码，并检查其工作原理。与使用std::prev_permutation的解决方案相比，该库极其高性能。该函数的实现相对简单，但该库还包含更多实现越来越复杂的功能（但同样易于使用）：

template <class BidirIter, class Function>
Function
for_each_combination(BidirIter first,
                     BidirIter mid,
                     BidirIter last,
                     Function f);

template <class BidirIter, class Function>
Function
for_each_permutation(BidirIter first,
                     BidirIter mid,
                     BidirIter last,
                     Function f);

template <class BidirIter, class Function>
Function
for_each_reversible_permutation(BidirIter first,
                                BidirIter mid,
                                BidirIter last,
                                Function f);

template <class BidirIter, class Function>
Function
for_each_circular_permutation(BidirIter first,
                              BidirIter mid,
                              BidirIter last,
                              Function f);

template <class BidirIter, class Function>
Function
for_each_reversible_circular_permutation(BidirIter first,
                                         BidirIter mid,
                                         BidirIter last,
                                         Function f);

图书馆有几个令人愉快的功能，包括：

您的输入序列（vector或其他）无需排序。
您可以通过返回true。
如果您没有提前退出循环，则序列始终返回其原始状态。
仿函数总是接收到序列的第一个k元素的迭代器，因此如果你告诉函子的总长度，也可以对未选择的元素进行操作。顺序。

随意使用该库，或者从实施中学习并获取所需的内容。上面的链接包含类似教程的描述，以及每个函数的详细说明。

Answer 2

从子集S = {1,2,3，...，k}开始，这是第一个子集。通过检查右边的元素（从最后一个开始）生成下一个子集，并在可能的情况下增加它（如果它是＆lt; N），并将其作为下一个子集返回。如果无法递增，请查看左侧的元素，直到找到可以递增的元素。递增它，并从该点开始按顺序设置元素。下面是{1,2,3,4,5}的3个元素子集（N = 5，k = 3，有10个子集）：

{1,2,3}，{1,2,4}，{1,2,5}，{1,3,4}，{1,3,5}，{1,4,5} ，{2,3,4}，{2,3,5}，{2,4,5}，{3,4,5}

#include <iostream>
#include <vector>

std::ostream& operator<<(std::ostream& o, std::vector<int>& a)
{
    o << "{";
    for (std::vector<int>::const_iterator it = a.begin(); it != a.end(); ++it) {
        o << *it;
        if (it + 1 < a.end()) o << ",";
    }
    return o << "}";
}

int main()
{
    const int N = 7;
    const int k = 4;

    std::vector<int> A(k);

    // initialize
    for (int i = 0; i < k; ++i) {
        A[i] = i + 1;
    }

    std::cout << A << std::endl;
    int h = 0;
    bool done = false;
    do {
        ++A[k-h-1];
        for (int t = k - h; t < k; ++t) {
            A[t] = A[t-1] + 1;
        }
        if (A[k-h-1] < N - h) {
            // last element can be incremented, stay there...
            h = 0;
        } else {
            // last element at max, look back ...
            ++h;
        }
        done = (A[0] == N - k + 1);
        std::cout << A << std::endl;    
    } while (!done);
}

Answer 3

非常简单的递归实现：

addresses

C ++中一系列数字的组合

3 个答案: