C++ 迭代计算集合或向量的幂集_C++_Set_Powerset

C++ 迭代计算集合或向量的幂集

c++

C++ 迭代计算集合或向量的幂集,c++,set,powerset,C++,Set,Powerset,虽然有很多关于如何生成集合的实际幂集的示例，但我找不到任何关于迭代（如std:：iterator）生成幂集的内容。我喜欢这种算法的原因是我的基集的大小。由于n元素集的幂集有2^n个元素，因此在实际计算该集时，我会很快耗尽内存。那么，有没有办法为给定集的幂集创建迭代器？有可能吗如果更简单的话，可以使用迭代器创建ints的集合，我可以将它们用作实际集合/向量的索引由于我实际上是在处理一个std:：vector，如果必要的话，随机访问是可能的对每个组合使用，可以轻松迭代std:：vector的

虽然有很多关于如何生成集合的实际幂集的示例，但我找不到任何关于迭代（如

std:：iterator

）生成幂集的内容。我喜欢这种算法的原因是我的基集的大小。由于n元素集的幂集有2^n个元素，因此在实际计算该集时，我会很快耗尽内存。那么，有没有办法为给定集的幂集创建迭代器？有可能吗

如果更简单的话，可以使用迭代器创建
```
int
```
s的集合，我可以将它们用作实际集合/向量的索引
由于我实际上是在处理一个
```
std:：vector
```
，如果必要的话，随机访问是可能的

对每个组合使用

，可以轻松迭代std:：vector的幂集的所有成员。例如：
#include <vector>
#include <iostream>
#include "../combinations/combinations"

int
main()
{
    std::vector<int> v{1, 2, 3, 4, 5};
    std::size_t num_visits = 0;
    for (std::size_t k = 0; k <= v.size(); ++k)
        for_each_combination(v.begin(), v.begin()+k, v.end(),
            [&](auto first, auto last)
            {
                std::cout << '{';
                if (first != last)
                {
                    std::cout << *first;
                    for (++first; first != last; ++first)
                        std::cout << ", " << *first;
                }
                std::cout << "}\n";
                ++num_visits;
                return false;
            });
    std::cout << "num_visits = " << num_visits << '\n';
}

我上面使用的语法是C++14。如果您有C++11，则需要更改：
[&](auto first, auto last)

致：
[&]（std:：vector:：const_迭代器优先，std:：vector:：const_迭代器最后）

如果您使用的是C++98/03，则必须编写一个函子或函数来替换lambda
对于每个\u组合
函数不分配额外的存储。这一切都是通过将向量的成员交换到[v.begin（），v.begin（）+k）
范围内来完成的。在每次调用结束时，每个组合的向量都保持其原始状态
如果出于某种原因，您希望提前“退出”每个组合的，只需返回true
，而不是false
使用每个组合的，就可以轻松地迭代std:：vector
的幂集的所有成员。例如：
#include <vector>
#include <iostream>
#include "../combinations/combinations"

int
main()
{
    std::vector<int> v{1, 2, 3, 4, 5};
    std::size_t num_visits = 0;
    for (std::size_t k = 0; k <= v.size(); ++k)
        for_each_combination(v.begin(), v.begin()+k, v.end(),
            [&](auto first, auto last)
            {
                std::cout << '{';
                if (first != last)
                {
                    std::cout << *first;
                    for (++first; first != last; ++first)
                        std::cout << ", " << *first;
                }
                std::cout << "}\n";
                ++num_visits;
                return false;
            });
    std::cout << "num_visits = " << num_visits << '\n';
}

我上面使用的语法是C++14。如果您有C++11，则需要更改：
[&](auto first, auto last)

致：
[&]（std:：vector:：const_迭代器优先，std:：vector:：const_迭代器最后）

如果您使用的是C++98/03，则必须编写一个函子或函数来替换lambda
for_each_composition
函数不分配额外的存储。这是通过将向量的成员交换到[v.begin（），v.begin（）+k）
范围内来完成的。在每次调用for_each_composition
时，向量保持其原始状态
如果出于某种原因，您希望提前“退出”每个组合的，只需返回true
，而不是false
使用每个组合的，就可以轻松地迭代std:：vector
的幂集的所有成员。例如：
#include <vector>
#include <iostream>
#include "../combinations/combinations"

int
main()
{
    std::vector<int> v{1, 2, 3, 4, 5};
    std::size_t num_visits = 0;
    for (std::size_t k = 0; k <= v.size(); ++k)
        for_each_combination(v.begin(), v.begin()+k, v.end(),
            [&](auto first, auto last)
            {
                std::cout << '{';
                if (first != last)
                {
                    std::cout << *first;
                    for (++first; first != last; ++first)
                        std::cout << ", " << *first;
                }
                std::cout << "}\n";
                ++num_visits;
                return false;
            });
    std::cout << "num_visits = " << num_visits << '\n';
}

我上面使用的语法是C++14。如果您有C++11，则需要更改：
[&](auto first, auto last)

致：
[&]（std:：vector:：const_迭代器优先，std:：vector:：const_迭代器最后）

如果您使用的是C++98/03，则必须编写一个函子或函数来替换lambda
for_each_composition
函数不分配额外的存储。这是通过将向量的成员交换到[v.begin（），v.begin（）+k）
范围内来完成的。在每次调用for_each_composition
时，向量保持其原始状态
如果出于某种原因，您希望提前“退出”每个组合的，只需返回true
，而不是false
使用每个组合的，就可以轻松地迭代std:：vector
的幂集的所有成员。例如：
#include <vector>
#include <iostream>
#include "../combinations/combinations"

int
main()
{
    std::vector<int> v{1, 2, 3, 4, 5};
    std::size_t num_visits = 0;
    for (std::size_t k = 0; k <= v.size(); ++k)
        for_each_combination(v.begin(), v.begin()+k, v.end(),
            [&](auto first, auto last)
            {
                std::cout << '{';
                if (first != last)
                {
                    std::cout << *first;
                    for (++first; first != last; ++first)
                        std::cout << ", " << *first;
                }
                std::cout << "}\n";
                ++num_visits;
                return false;
            });
    std::cout << "num_visits = " << num_visits << '\n';
}

我上面使用的语法是C++14。如果您有C++11，则需要更改：
[&](auto first, auto last)

致：
[&]（std:：vector:：const_迭代器优先，std:：vector:：const_迭代器最后）

如果您使用的是C++98/03，则必须编写一个函子或函数来替换lambda
for_each_composition
函数不分配额外的存储。这是通过将向量的成员交换到[v.begin（），v.begin（）+k）
范围内来完成的。在每次调用for_each_composition
时，向量保持其原始状态
如果出于某种原因您想“退出”早期的对于每个\u组合
只需返回true
而不是false
就可以使用一个由n
位组成的位集，初始化为零。在每一步中，用进位加1，就好像该位集表示一个n
位整数一样。使用产生的0和1模式来确定哪些元素属于该组合当前子集。重复，直到位集达到所有1。如果n谢谢@IgorTandetnik-这是关于如何处理此问题的常识，即我搜索不够努力吗？如果您将其作为一个添加，我会很高兴接受这个答案。使用一个n
位的位集，初始化为零。在每个步骤中，用进位添加1，就像这样位集表示一个n
-位整数。使用结果的0和1模式确定哪些元素属于当前子集。重复操作，直到位集达到所有1。如果n谢谢@IgorTandetnik-这是关于如何处理此问题的常识，即我搜索不够努力吗？我很乐意接受如果将其添加为一，则将其作为答案。使用一个由n
位组成的位集，初始化为零。在每个步骤中，使用进位添加1，就像该位集表示一个n
-位整数一样。使用结果的0和1模式来确定哪些元素属于当前子集。重复此操作，直到该位集达到所有1。如果n Thank you@IgorTandetnik-这是关于如何处理这个问题的常识吗，即我搜索不够努力吗？如果您将其作为一个进行添加，我很乐意接受这个答案。使用一个由n
位组成的位集，初始化为零。在每一步中，用进位添加1，如下所示