我有200个存储在vecOfVec中的大小为1到4000000的向量.我需要将这些向量与大小为9000+元素的单个向量"vecSearched"相交.我尝试使用以下代码执行相同操作,但是使用perf工具我发现我正在做的交叉点是我的代码中的瓶颈.我是否有某种方式可以执行有效的交叉路口
#include <cstdlib>
#include <iostream>
#include <vector>
using namespace std;
int main(int argc, char** argv) {
vector<vector<unsigned> > vecOfVec; //contains 120 vectors of size ranging from 1 to 2000000 elements. All vectors in vecOfVec are sorted
vector<unsigned> vecSearched; //vector searched in contains 9000+ elements. Vectors in vecSearched are sorted
for(unsigned kbt=0; kbt<vecOfVec.size(); kbt++)
{
//first find first 9 values spaced at equi-distant places, use these 9 values for performing comparisons
vector<unsigned> equiSpacedVec;
if(((vecSearched[0]))>vecOfVec[kbt][(vecOfVec[kbt].size())-1]) //if beginning of searched vector > last …我已经编写了以下多线程程序,用于使用std :: sort进行多线程排序.在我的程序中,grainSize是一个参数.由于grainSize或可以生成的线程数是系统相关的功能.因此,我没有得到应该将grainSize设置为的最佳值？我在Linux上工作？
int compare(const char*,const char*)
{
//some complex user defined logic
}
void multThreadedSort(vector<unsigned>::iterator data, int len, int grainsize)
{
if(len < grainsize)
{
std::sort(data, data + len, compare);
}
else
{
auto future = std::async(multThreadedSort, data, len/2, grainsize);
multThreadedSort(data + len/2, len/2, grainsize); // No need to spawn another thread just to block the calling thread which would do nothing.
future.wait();
std::inplace_merge(data, data + len/2, data + len, compare);
}
}
int main(int argc, char** argv) { …对于我的一个应用程序,我需要生成大小为2 ^ 35的向量(我的RAM的大小为96 GB,因此这个向量可以很容易地适应RAM).
int main ()
{
int i;
/* initialize random seed: */
srand (time(NULL));
vector<int> vec;
do {
i = rand() % 10 + 1;
vec.push_back(i);
} while ((vec.size()*sizeof(int))<pow(2,35));
return 0;
}
但是,我注意到我的while while循环无限执行.其中一个可能的原因是vec.size()long unsigned int的范围,它远远小于插入的元素的数量pow(2,35),因为我认为它在无限循环中.我可能错了.如果我错了,请纠正我.但有人可以告诉我如何pow(2,35)在vec中插入大于数字的数字.
gcc版本:4.8.2
我有一个无符号矢量矢量.我需要找到所有这些无符号向量的交集,这样做我写了下面的代码:
int func()
{
vector<vector<unsigned> > t;
vector<unsigned> intersectedValues;
bool firstIntersection=true;
for(int i=0;i<(t).size();i++)
{
if(firstIntersection)
{
intersectedValues=t[0];
firstIntersection=false;
}else{
vector<unsigned> tempIntersectedSubjects;
set_intersection(t[i].begin(),
t[i].end(), intersectedValues.begin(),
intersectedValues.end(),
std::inserter(tempIntersectedSubjects, tempIntersectedSubjects.begin()));
intersectedValues=tempIntersectedSubjects;
}
if(intersectedValues.size()==0)
break;
}
}
每个单独的向量具有9000个元素,并且在"t"中存在许多这样的向量.当我分析我的代码时,我发现set_intersection占用了最大的时间,因此当有很多func()调用时,代码会变慢.有人可以建议我如何使代码更有效.
我正在使用:gcc(GCC)4.8.2 20140120(Red Hat 4.8.2-15)
编辑:对矢量"t"中的各个矢量进行排序.
我有以下数据结构:
std::vector<std::pair <std::vector<unsigned>,std::vector<unsigned> > > A;
包含以下数据:
((7),(108,109)),
((3),(100,101)),
((9),(111,112)),
((5),(102,103)),
((8),(110)),
((8,2,10),(189)),
((5,7),(121)),
((3,9),(119)),
((10),(114)),
((3,5),(115)),
((3,7),(118)),
((3,10),(120)),
((3,4,5),(122))
现在我想以下列方式从A对向量中仅排序第一个向量.例如,我从A的向量对中的第一个向量是:
(7),
(3),
(9),
(5),
(8),
(8,2,10),
(5,7),
(3,9),
(10),
(3,5),
(3,7),
(3,10),
(3,4,5)
我想根据第一个向量对A进行排序,这样在最终排序后我的向量变为:
((3),(100,101)),
((5),(102,103)),
((7),(108,109)),
((8),(110)),
((9),(111,112)),
((10),(114)),
((3,5),(115)),
((3,7),(118)),
((3,9),(119)),
((3,10),(120)),
((5,7),(121)),
((3,4,5),(122)),
**((2,8,10),(189)).**
我知道如何使用std:sort对矢量进行排序,但我不确定如何使用标准c ++函数对矢量矢量进行排序.我尝试先按大小对它们进行排序,然后使用bublee排序进行最终排序.是否有其他方法使用标准库函数在c ++中对这些向量进行排序.我使用g ++编译器(g ++(Ubuntu/Linaro 4.6.3-1ubuntu5)4.6.3)在ubuntu 12.04上运行C++.
我有以下优先级队列：
#include <iostream>
#include <queue>
#include <iomanip>
using namespace std;
struct Time {
int h; // >= 0
int m; // 0-59
int s; // 0-59
};
class CompareTime {
public:
bool operator()(Time& t1, Time& t2)
{
if (t1.h < t2.h) return true;
if (t1.h == t2.h && t1.m < t2.m) return true;
if (t1.h == t2.h && t1.m == t2.m && t1.s < t2.s) return true;
return false;
}
};
int main()
{
priority_queue<Time, vector<Time>, CompareTime> pq;
// Array …我需要在下面的向量中推送66,000个向量(向量的数量不固定,它也可以是90,000个向量.为了简洁起见,我将以66,000个向量的示例显示以下代码)类型向量:
vector<int> vec;
66,000个向量中每个向量的大小为9,000个元素.我正在使用以下内容做同样的事情:
vec.reserve(66000*9000);
for(int j=0;j<66000;j++)
for(int i=0;i<9000;i++) //9000 elements in vec1[i] per vector is not fixed
vec.push_back(vec1[i]); //i am pushing i as an example
有没有什么可以提高这段代码的效率？
我需要连接太多的向量,因此相同的解决方案可能不同于连接两个向量.另外,我不能使用上一个问题中提到的多线程
我有一个vector<unsigned>大小(90,000 * 9,000).我需要多次查找此向量中是否存在元素？
为此,我使用排序的形式存储了矢量std::sort(),然后使用矢量查找矢量中的元素std::binary_search().但是在使用perf我的分析时,我发现查找元素vector<unsigned>是最慢的操作.
有人建议一些data-structure中C/C++,我可以用它来高效地查找元素的矢量(90,000 * 9,000)元素.
我只执行一次插入(批量插入).剩下的时间我只执行查找,所以这里的主要开销是因为查找.
我有一个向量对（V1，V2）对的向量，其形式为pairV1V2：
(1,2,3),(938,462,4837) -> (V1,V2)
(3,9,13),(938,0472,944)
(81,84,93),(938,84,845)
然后，我需要保留以下内容：
(1,2,3),(938,462,4837) -> (V1,V2)
(3,9,13),(938,0472,944)
(81,84,93),(84,845)
我需要从头开始扫描pairV1V2，无论哪里两个V1不相等，我都需要从V2中删除相交的元素。我写了下面的代码做同样的事情。但是，我的代码效率很低，因为向量对V1V2很大，并且在V2中有很多元素（大约10亿个）。
int main(int argc, char** argv) {
std::vector<std::pair<std::vector<unsigned>, std::vector<unsigned> > > pairV1V2;
std::vector<std::pair <std::vector<unsigned>,std::vector<unsigned> > >::iterator itm2,lm2=pairV1V2.end();
for(std::vector<std::pair <std::vector<unsigned>,std::vector<unsigned> > >::iterator itm=pairV1V2.begin(), lm=pairV1V2.end(); itm!=lm; ++itm)
{
//Outer values
vector<unsigned> outerV1=(*itm).first;
vector<unsigned> outerV2=(*itm).second;
sort(outerV2.begin(), outerV2.end());
itm2=itm;
itm2++;
for(itm2;itm2!=lm2;++itm2)
{
vector<unsigned> innerV1=(*itm2).first;
vector<unsigned> innerV2=(*itm2).second;
vector<unsigned> setDiffV1;
std::set_difference(innerV1.begin(), innerV1.end(), outerV1.begin(), outerV1.end(),
std::inserter(setDiffV1, setDiffV1.end()));
if(setDiffV1.size()==0) //check whether any two V1's are different
{
sort(innerV2.begin(), innerV2.end());
if((itm->second.size()!=0)&&(itm2->second.size()!=0)){
std::vector<unsigned> delIntersectingElem;
std::set_intersection(outerV2.begin(),outerV2.end(),innerV2.begin(), innerV2.end(),
std::back_inserter(delIntersectingElem));
if(delIntersectingElem.size()!=0) …