有一个很好的C++解决方案(实际上是2个解决方案:递归和非递归),是一个整数向量向量的笛卡尔积.出于说明/简单的目的,让我们只关注非递归版本.
我的问题是,如何用模板推广这个代码来获取std::tuple看起来像这样的同类向量:
{{2,5,9},{"foo","bar"}}
并生成一个齐次的矢量 tuple
{{2,"foo"},{2,"bar"},{5,"foo"},{5,"bar"},{9,"foo"},{9,"bar"}}
如果它让生活更容易,让我们假设输入中的内部向量都是同质的.所以不允许这样的输入: {{5,"baz"}{'c',-2}}
编辑将输入从锯齿状矢量更改为元组
c++ algorithm data-structures template-meta-programming c++11
我有几个看起来像这样的数据:
Vector1_elements = T,C,A
Vector2_elements = C,G,A
Vector3_elements = C,G,T
..... up to ...
VectorK_elements = ...
#Note also that the member of each vector is always 3.
我想要做的是通过VectorK在Vector1中创建所有元素组合.因此最后我们希望得到这个输出(使用Vector1,2,3):
TCC
TCG
TCT
TGC
TGG
TGT
TAC
TAG
TAT
CCC
CCG
CCT
CGC
CGG
CGT
CAC
CAG
CAT
ACC
ACG
ACT
AGC
AGG
AGT
AAC
AAG
AAT
我现在遇到的问题是我的下面的代码通过硬编码循环来做到这一点.由于Vector的数量可以变化,我们需要一种灵活的方法来获得相同的结果.有没有？
我的这段代码最多只能处理3个矢量(硬编码):
#include <iostream>
#include <vector>
#include <fstream>
#include <sstream>
using namespace std;
int main ( int arg_count, char *arg_vec[] ) {
vector <string> …可能重复:
如何创建向量矢量的笛卡尔积？
我有一些逻辑问题,想出如何在二维矢量中生成元素的所有组合.在这里,我创建了一个2D矢量.两个维度的大小都不能假设.
#include <iostream>
#include <vector>
using namespace std;
int main() {
srand(time(NULL));
vector< vector<int> > array;
// This creates the following:
// array[0]: {0, 1, 2}
// array[1]: {3, 4, 5, 9}
// array[2]: {6, 7, 8}
for(int i=0; i<3; i++) {
vector<int> tmp;
tmp.push_back((i*3)+0); tmp.push_back((i*3)+1); tmp.push_back((i*3)+2);
if(i==1)
tmp.push_back((i*3)+6);
array.push_back(tmp);
}
}
创建向量后,我想输出所有可能的组合,如下所示:
comb[0] = {0, 3, 6}
comb[1] = {0, 3, 7}
comb[2] = {0, 3, 8}
comb[3] = {0, 4, 6}
comb[4] = {0, 4, 7} …我正在研究一组n维笛卡尔积类型,基于这个解决方案.
对于相同的基本算法集,我有许多不同的数据类型,我想"啊哈!我将使用模板来减少我的整体工作!" 而且,到目前为止,它一直很棒.我正在使用Boost的iterator_facade.
我的问题是我使用的派生类map<char, boost::integer_range<int> >.每次迭代产生一个map<char,int>,但我排除第二个值为0的对,因为就我的算法而言,它们只是浪费空间.
派生类重载生成迭代器的返回值的函数,并且它可以工作.但是,在第一次迭代期间,将调用基类的生成器.我很困惑.有没有人有任何想法？
以下是相关的代码段:
#include <boost/container/flat_map.hpp>
#include <boost/tuple/tuple.hpp>
#include <boost/iterator/iterator_facade.hpp>
#include <boost/range/irange.hpp>
#include <utility>
#include <iostream>
using namespace boost;
using namespace boost::tuples;
using namespace std;
template <class Container2DMap,
class return_type = boost::container::flat_map<typename Container2DMap::value_type::first_type,
typename Container2DMap::value_type::second_type::value_type> >
class CartProductIterator2DMap : public boost::iterator_facade<
CartProductIterator2DMap<Container2DMap, return_type>,
const return_type,
boost::forward_traversal_tag> {
public:
typedef typename Container2DMap::value_type::first_type first_type;
typedef typename Container2DMap::const_iterator first_iterator;
typedef typename Container2DMap::value_type::second_type::value_type second_type;
typedef typename Container2DMap::value_type::second_type::const_iterator second_iterator;
CartProductIterator2DMap(const Container2DMap &container) {
rangeIterSetup(container);
} …之前已经提出了类似的问题,但我找不到与我的问题完全匹配的问题.
我有4个向量,每个向量保持200-500个4位整数.每个向量中元素的确切数量各不相同,但我可以将其修复为特定值.我需要找到这4个向量中所有元素的可能组合.
例如:
v1 [10,30] v2 [11,45] v3 [63,56] v4 [82,98]
所以我会得到这样的东西:
[10,11,63,82]; [30,11,63,82]; [10,45,63,82]; [10,45,56,82]等..
这个算法有一个共同的名称,所以我可以在网上找到一些参考吗？否则,在C++中实现它的任何提示都会有所帮助.性能不是问题,因为我只需要运行一次算法.STL中是否有任何内置功能？
我一直在寻找关于如何提出可以应用笛卡尔积的代码段的数周时间。假设我有两个数组：
int M[2]= {1,2};
int J[3] = {0,1,2};
所以代码将采用这两个数组应用规则 MXJ 因此我们将有 (1,0)(1,1)(1,2)(2,0)(2,1)(2,2) 和我希望将新结果保存到一个新数组中，其中数组中的每个索引都包含一个 pair ，例如 c[0] = (1,0)。请帮忙 ：（
假设有n个级别,在每个级别中你可以选择两个可能的字符中的一个,打印所有可能的字符串,
例如: -
假设我们有3个级别: -
level1: - ab
level2: - cd
level3: - ef
可能的字符串是: - 1. ace
2. acf
3. ade
4. adf
5. bce
6. bcf
7. bde
8. bdf
我知道样本空间是2 ^ n所以所需的时间是O(2 ^ n),但我无法弄清楚如何编写它.有什么可能的方法和我必须阅读哪些主题来解决这些问题？