blocks|key|4307465|text|您可以简单地使用std::to_string()将所建议的算法转换为int。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4307466|void+printAll(const+std::vector<std::vector<int>+>+&allVecs,+size_t+vecIndex,+std::string+strSoFar)
{
++++if+(vecIndex+>=+allVecs.size())
++++{
++++++++std::cout+<<+strSoFar+<<+std::endl;
++++++++return;
++++}
++++for+(size_t+i=0;+i<allVecs[vecIndex].size();+i%2B%2B)
++++++++printAll(allVecs,+vecIndex%2B1,+strSoFar%2Bstd::to_string(allVecs[vecIndex][i]));
}|code-block|syntax|javascript|4307467|entityMap^0|8|G|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

You can simply convert it the proposed algorithm into int using <code>std::to_string()</code>.

<pre><code>void printAll(const std::vector&lt;std::vector&lt;int&gt; &gt; &amp;allVecs, size_t vecIndex, std::string strSoFar)
{
 if (vecIndex &gt;= allVecs.size())
 {
 std::cout &lt;&lt; strSoFar &lt;&lt; std::endl;
 return;
 }
 for (size_t i=0; i&lt;allVecs[vecIndex].size(); i++)
 printAll(allVecs, vecIndex+1, strSoFar+std::to_string(allVecs[vecIndex][i]));
}
</code></pre>

blocks|key|2269104|text|与其使用递归函数(它可以工作，但在实践中可能很笨拙)，我更愿意把它作为一个简单的计数问题来处理。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2269105|让我们从一个简单的假设开始:我们每个有3个由10个元素组成的数组。在这种情况下，很明显，我们可以打印出所有的组合，只需计算从0(我们认为是000)到999，并使用每个数字作为下标到适当的子向量。|2269106|每个子向量有10个条目，或者在每个子向量中有相同数量的项目，这是没有魔力的。只是碰巧每个数组中有10个条目，每个数组中的索引对应于我们习惯于在基数为10的数字中看到/使用的数字。|2269107|当我们处理基数为10的数字时，我们可以使用除以10后的余数来得到我们需要的每一个数字。对于手头的任务，我们可以做大致相同的，除了我们使用除法在一个子数组中的元素数代替。|2269108|因此，让我们从计算输入中的组合数开始(目前，我们假设每个子向量都有一个非零大小)：|2269109|size_t+max+=+1;

for+(auto+const+&v+:+allVecs)
++++max+*=+v.size();|code-block|syntax|javascript|2269110|然后，我们简单地计算从0到max，在除以相应的向量大小之后取余数，并使用它们索引到子向量：|offset|length|style|CODE|2269111|for+(size_t+i=0;+i<max;+i%2B%2B)+{
++++auto+temp+=+i;
++++for+(auto+const+&vec+:+allVecs)+{
++++++++auto+index+=+temp+%25+vec.size();
++++++++temp+/=+vec.size();
++++++++std::cout+<<+vec[index]+<<+'+';
++++}
++++std::cout+<<+'\n';
}|2269112|就目前的情况而言，这有一点可能令人困惑或有问题:它以与您可能期望的顺序相反的方式输出结果。例如，它不显示作为第一个输出的1+5+11，而是显示11+5+1。如果这是不可接受的，有一些简单的方法来纠正这种情况。最简单的方法可能是从简单地反转输入向量开始：|2269113|std::reverse(allVecs.begin(),+allVecs.end());|2269114|如果你有任何希望产生组合，永远完成，输入向量将是足够小的，这个O(N)运算对任何事情都没有什么影响。|2269115|entityMap^0|0|0|0|0|0|0|B|1|D|3|0|0|1O|6|1Z|6|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|15|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|16|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|17|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|18|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|19|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|1A|8|@$Q|1B|R|1C|S|T]|$Q|1D|R|1E|S|T]]|9|@]|A|$]]|$1|U|3|V|5|L|7|1F|8|@]|9|@]|A|$M|N]]|$1|W|3|X|5|6|7|1G|8|@$Q|1H|R|1I|S|T]|$Q|1J|R|1K|S|T]]|9|@]|A|$]]|$1|Y|3|Z|5|L|7|1L|8|@]|9|@]|A|$M|N]]|$1|10|3|11|5|6|7|1M|8|@]|9|@]|A|$]]|$1|12|3|-4|5|6|7|1N|8|@]|9|@]|A|$]]]|13|$]]

Rather than a recursive function (which works, but can be clumsy in practice) I prefer to treat this as a simple problem of counting.

Let's start with a simplifying assumption: that we have 3 arrays of 10 elements apiece. In this case, it's obvious that we can print out all combinations simply by counting from 0 (which we'd think of as 000) to 999, and using each digit as a subscript into the appropriate sub-vector.

There's no magic to having 10 items per sub-vector, or having the same number of items in each sub-vector. It just happens that with 10 items apiece, the index into each array corresponds to the digits we're accustomed to seeing/using in base 10 numbers.

When we're dealing with base 10 numbers, we can use the remainder after division by 10 to get each digit we need. For the task at hand, we can do roughly the same, except that we use division by the number of elements in a sub-array instead.

So, let's start by computing the number of combinations in the inputs (for the moment, we'll assume each sub-vector has a non-zero size):

<pre><code>size_t max = 1;

for (auto const &amp;v : allVecs)
 max *= v.size();
</code></pre>

Then we simply count from <code>0</code> to <code>max</code>, take the remainder after dividing by the respective vector size, and using those to index into the sub-vectors:

<pre><code>for (size_t i=0; i&lt;max; i++) {
 auto temp = i;
 for (auto const &amp;vec : allVecs) {
 auto index = temp % vec.size();
 temp /= vec.size();
 std::cout &lt;&lt; vec[index] &lt;&lt; ' ';
 }
 std::cout &lt;&lt; '\n';
}
</code></pre>

As it stands right now, this has one point that might find confusing or problematic: it prints out the results in the reverse of the order you might expect. For example, instead of the <code>1 5 11</code> you show as the first output, it would show <code>11 5 1</code>. If this is unacceptable, there are a number of easy ways to rectify the situation. The easiest is probably to start by simply reversing the input vector:

<pre><code>std::reverse(allVecs.begin(), allVecs.end());
</code></pre>

If you have any hope of generating the combinations to ever finish, the input vector is going to be small enough for this O(N) operation to have little effect on anything.

I would like to create the combinations of several vectors 

<pre><code>vector&lt;int&gt; Vec1;
Vec1.push_back(1);
Vec1.push_back(2);
Vec1.push_back(3);

vector &lt;int&gt; Vec2;
Vec2.push_back(5);
Vec2.push_back(6);
Vec2.push_back(7);
Vec2.push_back(8);

vector &lt;int&gt; Vec3;
Vec3.push_back(11);
Vec3.push_back(12);
Vec3.push_back(13);

vector&lt;vector&lt;int&gt;&gt; xt;
xt.push_back(Vec1);
xt.push_back(Vec2);
xt.push_back(Vec3);
</code></pre>

The results should be something like

1 5 11 
1 5 12 
... 
3 8 13 

I could use nest loop for a given number of vectors. However, I am trying to write a function, like 
void printAll(const vector > &amp;xt)
I did find something similar 

<a href="https://stackoverflow.com/questions/1700079/howto-create-combinations-of-several-vectors-without-hardcoding-loops-in-c">Howto create combinations of several vectors without hardcoding loops in C++?</a>

But I am struggling converting it into int. Please offer me some suggestions.

Create all possible combinations of multiple vectors

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我想要创建几个向量的组合vector<int> Vec1;Vec1.push_back(1);Vec1.push_back(2);Vec1.push_back(3);vector <int> Vec2;Vec2.push_back(5);Vec2.push_back(6);Vec2.push_back(7);Vec2....

问创建多个向量的所有可能组合
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问创建多个向量的所有可能组合EN