stl测试

最新推荐文章于 2023-07-10 14:14:41 发布
最新推荐文章于 2023-07-10 14:14:41 发布
阅读量146 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/yinwuxiao/p/9915598.html
版权

以下测试都在学校电脑进行 我觉得应该比考试机器慢一点。。

1.map

map的速度测出来和放入数值大小有很大关系

比如 

#include <bits/stdc++.h>
using namespace std;
#define rep(i,h,t) for (int i=h;i<=t;i++)
const int N=1e6;
const int mo=100;
map<int,int> M;
int main()
{
  freopen("1.in","r",stdin);
  freopen("1.out","w",stdout);
  rep(i,1,N)
  {
    int x=rand()%mo;
    M[x]++;
  }
  int ans=0;
  rep(i,1,N)
  {
    int x=rand()%mo+1,y=rand()%mo+1;
    ans+=M[x]-M[y];
  }
  cout<<ans<<endl;
  return 0;
}

在mo=100的时候开O2仅0.4s 不开O2 1.2s

而在mo=1e9的情况下开O2跑了7s 不开O2跑了12s

于是我尝试了一下hash 开不开O2都差不多0.7s

#include <bits/stdc++.h>
using namespace std;
#define rep(i,h,t) for (int i=h;i<=t;i++)
const int N=1e6;
const int mo=1000000000;
map<int,int> M;
const int hashmo=1e7+7;
struct re{
  int a,b;
}ha[hashmo+100000];
struct hash{
  void insert(int x)
  {
    int y=x%hashmo;
    while (ha[y].a&&ha[y].a!=x) y++;
    ha[y].a=x; ha[y].b++;
  }
  int find(int x)
  {
    int y=x%hashmo;
    while (ha[y].a&&ha[y].a!=x) y++;
    return ha[y].b;
  }
}H;
int main()
{
  freopen("1.in","r",stdin);
  freopen("1.out","w",stdout);
  rep(i,1,N)
  {
    int x=rand()%mo;
    H.insert(x);
  }
  int ans=0;
  rep(i,1,N)
  {
    int x=rand()%mo+1,y=rand()%mo+1;
    ans+=H.find(x)-H.find(y);
  }
  cout<<ans<<endl;
  return 0;
}

gprof了一下

% cumulative self self total
time seconds seconds calls ns/call ns/call name

50.00 0.27 0.27 2000000 135.00 135.00 hash::find(int)
42.59 0.50 0.23 1000000 230.00 230.00 hash::insert(int)

所以不到没有时间或者题目时间对这个很宽松的时候（或者这个比较难写hash）

尽量使用手写hash

hash在5e6的时候

不开O2 3.7s 开O2 3.7s

所以考试的上限大概就这么多了

当然hash在模数较小的情况下表现也会更好

2.set

首先set的操作比较多，先说一下

insert嘛人人都知道

find注意只能查找这个元素，如果没有就会指向end（空）

lower_bound 查找.>=x的最小元素 upper_bound 查找>x的最小元素

erase(x) 删去所有等于x的元素 注意如果你用multiset然后想只删一个 那么可以it=S.find() S.earse(it)

count(x) 查找=x的元素个数（这个操作并没有啥用因为可以用map）

但是有的时候我们需要重载运算符

如下

#include <bits/stdc++.h>
using namespace std;
#define rint register int
#define IL inline
#define rep(i,h,t) for (int i=h;i<=t;i++)
#define dep(i,t,h) for (int i=t;i>=h;i--)
struct cmp{
  bool operator () (int x,int y)
  {
    return x>y;
  }
};
set<int,cmp> S;
int main()
{
  freopen("1.in","r",stdin);
  freopen("1.out","w",stdout);
  
  
  return 0;
}

这样就定义了从大到小的set

但这种情况下假如要用lower_bound怎么办呢

我们测试一下

#include <bits/stdc++.h>
using namespace std;
#define rint register int
#define IL inline
#define rep(i,h,t) for (int i=h;i<=t;i++)
#define dep(i,t,h) for (int i=t;i>=h;i--)
struct cmp{
  bool operator () (int x,int y)
  {
    return x>y;
  }
};
set<int,cmp> S;
int main()
{
  freopen("1.in","r",stdin);
  freopen("1.out","w",stdout);
  S.insert(1); S.insert(2); S.insert(3); S.insert(4);
  cout<<*S.upper_bound(4)<<" "<<*S.lower_bound(4)<<endl;
  return 0;
}

输出的是3,4

其实我们可以这么去看，现在元素是从大到小排序

我们upper_bound 是查找这个数右边（不包括自己） 而lower_bound是查找这个数右边包括自己的

于是这样我们就可以在cmp后继续使用lower/upper _bound查找了

但是现在还有一个问题，如果我想查找<=x的最大数呢

方案1：修改cmp

方案2：S.upper_bound()-- (当然要特判断一下不存在）

如果查找<x的最大数呢

方案2：S.lower_bound()--（同理也得特判）

另一个问题是set的遍历

有的时候我们写启发式合并然后时间比较宽松就会用set来替代

（平衡树毕竟个人感觉是最难调的数据结构）

for (it=S.begin();it!=S.end();it++) 这样遍历

有的时候我们需要求it的后继但并不像改变it的值,可以这么写

#define setit set<int>::iterator

setit scc(setit it )

{

  setit it2=it; it2++; return it2;

}

这就是it的基本操作了

接下来开始测速度

#include <bits/stdc++.h>
using namespace std;
#define rint register int
#define IL inline
#define rep(i,h,t) for (int i=h;i<=t;i++)
#define dep(i,t,h) for (int i=t;i>=h;i--)
#define ll long long
struct cmp{
  IL bool operator () (int x,int y)
  {
    return x>y;
  }
};
set<int,cmp> S;
set<int,cmp>::iterator it;
int main()
{
  freopen("1.in","r",stdin);
  freopen("1.out","w",stdout);
  int n=1e6;
  rep(i,1,n) S.insert(rand());
  ll ans=0;
  for (it=S.begin();it!=S.end();it++)
  {
    ans+=*it;
  }
  cout<<ans<<endl;
  return 0;
}

不开O2 3s 开O2 2s 

#include <bits/stdc++.h>
using namespace std;
#define rint register int
#define IL inline
#define rep(i,h,t) for (int i=h;i<=t;i++)
#define dep(i,t,h) for (int i=t;i>=h;i--)
#define ll long long
struct cmp{
  IL bool operator () (int x,int y)
  {
    return x>y;
  }
};
set<int,cmp> S;
set<int,cmp>::iterator it;
int main()
{
  freopen("1.in","r",stdin);
  freopen("1.out","w",stdout);
  int n=1e6;
  rep(i,1,n) S.insert(rand()%100);
  ll ans=0;
  for (it=S.begin();it!=S.end();it++)
  {
    ans+=*it;
  }
  cout<<ans<<endl;
  return 0;
}

不开O2 0.5s 开O2 0.3s

这个代码和刚才一样

当数值都较小时就快很多

我不是很清楚原理

不过这也告诉了我们离散化在卡常上挺重要的

#include <bits/stdc++.h>
using namespace std;
#define rint register int
#define IL inline
#define rep(i,h,t) for (int i=h;i<=t;i++)
#define dep(i,t,h) for (int i=t;i>=h;i--)
#define ll long long
struct cmp{
  IL bool operator () (int x,int y)
  {
    return x>y;
  }
};
set<int,cmp> S;
set<int,cmp>::iterator it;
int main()
{
  freopen("1.in","r",stdin);
  freopen("1.out","w",stdout);
  int n=1e6;
  rep(i,1,n) S.insert(rand());
  ll ans=0;
  rep(i,1,n) ans+=*S.find(rand());
  cout<<ans<<endl;
  return 0;
}

不开O2 4.6s 开O2 3.6s

同理把find变成upper_bound时间几乎差不多

所以考试的时候 当数据范围不是很大的时候 1e6次插入基本可以接受

3.vector

#include <bits/stdc++.h>
using namespace std;
#define rint register int
#define IL inline
#define rep(i,h,t) for (int i=h;i<=t;i++)
#define dep(i,t,h) for (int i=t;i>=h;i--)
#define ll long long
vector<int> ve;
int main()
{
  freopen("1.in","r",stdin);
  freopen("1.out","w",stdout);
  int n=1e7;
  rep(i,1,n) ve.push_back(rand());
  ll ans=0;
  rep(i,1,n) ans+=ve[i-1];
  cout<<ans<<endl;
  return 0;
}

不开O2 0.85s 开O2 0.75s

#include <bits/stdc++.h>
using namespace std;
#define rint register int
#define IL inline
#define rep(i,h,t) for (int i=h;i<=t;i++)
#define dep(i,t,h) for (int i=t;i>=h;i--)
#define ll long long
const int N=2e7;
int ve[N];
int main()
{
  freopen("1.in","r",stdin);
  freopen("1.out","w",stdout);
  int n=1e7;
  rep(i,1,n) ve[i]=rand();
  ll ans=0;
  rep(i,1,n) ans+=ve[i-1];
  cout<<ans<<endl;
  return 0;
}

而数组 不开O2 0.55s 开O2 0.4s

这说明了的确会慢一点

再大的数组一般用不到 大的数组访问还是挺慢的

4.queue

#include <bits/stdc++.h>
using namespace std;
#define rint register int
#define IL inline
#define rep(i,h,t) for (int i=h;i<=t;i++)
#define dep(i,t,h) for (int i=t;i>=h;i--)
#define ll long long
queue<int> q;
int main()
{
  freopen("1.in","r",stdin);
  freopen("1.out","w",stdout);
  int n=1e7;
  rep(i,1,n) q.push(rand());
  ll ans=0;
  rep(i,1,n) ans+=q.front();
  cout<<ans<<endl;
  return 0;
}

不开O2 2s 的确是非常的慢

不过开O2 0.6s？？？？ 这个还可以

所以在一些线性算法时间比较仅的情况下 尽量使用数组

5.deque

这个东西让我很震惊

#include <bits/stdc++.h>
using namespace std;
#define rint register int
#define IL inline
#define rep(i,h,t) for (int i=h;i<=t;i++)
#define dep(i,t,h) for (int i=t;i>=h;i--)
#define ll long long
deque<int> q;
int main()
{
  freopen("1.in","r",stdin);
  freopen("1.out","w",stdout);
  int n=1e7;
  rep(i,1,n) q.push_front(rand());
  ll ans=0;
  rep(i,1,n) ans+=q.front();
  cout<<ans<<endl;
  return 0;
}

不开O2 1s 开O2 0.5s

比queue快是什么操作啊。。

这个东西简直是个神仙东西。。

还有各种操作。。（在雅礼里面写了 下次再补）

6.priority_queue

这个东西强O2需要求啊。。

#include <bits/stdc++.h>
using namespace std;
#define rint register int
#define IL inline
#define rep(i,h,t) for (int i=h;i<=t;i++)
#define dep(i,t,h) for (int i=t;i>=h;i--)
#define ll long long
priority_queue<int> q;
int main()
{
  freopen("1.in","r",stdin);
  freopen("1.out","w",stdout);
  int n=1e6;
  rep(i,1,n) q.push(rand());
  ll ans=0;
  rep(i,1,n) ans+=q.top(),q.pop();
  return 0;
}

不开O2 3s 开O2 0.6s

也就是说不开O2下和set速度差不多 开O2吊打set

像去年d1t3 最坏情况下5e6次priority操作 所以开始写就要意识常数问题了

最短路一般没什么优化余地 我去网上看了一下线段树和堆优化

几乎跑的差不多

转载于:https://www.cnblogs.com/yinwuxiao/p/9915598.html

weixin_30287169
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
半导体芯片测试介绍：CP、FT、STL
m0_49968063的博客
06-20 4504
这种老化测试一般是对车规级类别芯片在FT结束后放入高温环境中洗个澡，并加上高压，测试几个小时就相当于过了几周，然后再进行测试，不好的淘汰掉，好的进行出货，这个高温环境测试过程称为老化测试。芯片封装完成之后，通过分选机和测试机的配合使用，对芯片功能和电参数性能进行的一些列测试。这一般是芯片出厂前的最后一道拦截，以保证芯片性能和功能满足要求。对Wafer进行电性能测试，挑选出好的Die,可以减少封装和测试的成本，也可以透过Wafer的良率，检查fab厂制造的工艺水平。
STL简单测试题
Scholar618的博客
04-22 291
第一个参数是字符串的起始位置，第二个参数是字符串的终点位置，第三个是init求和初始化，即为求和累加器，第四个是一个Lambda表达式，用于自定义累加操作（若没有第四个参数，即为起始位置到终点位置和累加器的和）查阅资料发现，代码中定义的vInt_Max迭代器指向的是vIntA.end()，而不是vIntA中的最大值。因此，输出的最大值是未定义的，可能会导致程序出现错误(vInt_Min没有影响)函数将得到一个指向容器尾部的迭代器，但是这个迭代器并不能用于访问容器中的元素，因为它指向的是一个不存在的元素。
STL分析（一）泛型编程，测试容器
janke114的博客
01-08 102
STL
STL的算法部分测试
IS_MOKE的博客
09-04 159
STL的算法部分测试
侯捷STL 6. 容器之分类与各种测试 (四)
m0_73602247的博客
07-10 79
【代码】侯捷STL 6. 容器之分类与各种测试 (四)
stl、obj、3ds—3D模型文件
12-17
stl、obj、3ds是三种不同的3D模型文件，用于3D模型显示，可直接导入到vtk中，配合本站vtk总结文章网址：https://blog.csdn.net/qq_40155090/article/details/111310107（PyQT5+VTK8加载3D模型（obj、stl、3ds）汇总...
STL测试程序map的使用方法
09-12
使用VC++控制台程序编写，使用map对多元obj按规定单元的大小进行排序
STL容器之array和vector.zip
10-07
这里包含了array定长数组和vector动态数组的实现和测试代码
stl模型-机器小人-测试模型
01-04
方便侧睡的stl模型，文件不大。stl模型-机器小人-测试模型
3D打印测试文件
01-17
各种3D打印机性能测试的零件，该零件能打好，说明机器的性能不错。
STL 标准库算法测试
weixin_42762863的博客
08-04 127
头文件为 algorithm , 算法由all_of, any_of, sort #include <iostream> #include <vector> #include <algorithm> //all_of template <typename T> class Test_std_algorithm { public: void add_vector_para(const T& a) { vec.push_back(a); } vo
STL性能测试
热门推荐
陈硕的Blog
10-03 1万+
 作者主页http://www.chenshuo.com可下载测试文本与源代码C++ Standard Template Library——STL的性能究竟如何，不同版本的STL其性能差异有多少？为了解这些，让我们来做一个简单的测试吧。测试的基本思路是用C与C++分别实现一个程序，实现相同的功能，并要求C++程序的主要数据结构用STL中的Containers、Algorithms等来实现。
最先进的软件测试库 (STL) 和 ASIL B：真理、神话和指导
LIAOYUANGANG的博客
03-14 8002
1. 简介 功能安全在一系列市场中仍然至关重要，随着自动驾驶和相关服务成为现实，功能安全是决定其成功和广泛部署的关键因素。关键性越高，驾驶员对应用程序的控制越少，固有风险和相关的汽车安全完整性等级 (ASIL) 就越高。 ISO 26262 [1] 定义了四种 ASIL： 1. ASIL A（最低完整性） 2. ASIL B 3. ASIL C 4. ASIL D（最高完整性） ASIL 根据安全目标和功能安全要求的定义在车辆级别确定。对于每个功能安全要求，...
STL基本容器测试
生活需要深度
06-20 299
标准STL
测试STL
fffzlfk的博客
12-31 254
#include&lt;vector&gt; #include &lt;iostream&gt; #include&lt;algorithm&gt; using namespace std; void fill_random_int(vector&lt;int&gt;&amp; v,int cnt) { v.clear(); for(int i=0;i&lt;cnt;i++) ...
STL测试
qq_23350817的博客
03-04 354
array&lt;int, 3&gt; arr{ 1,2,3 }, arr1{4,5,6}; arr.begin(); arr.end(); arr.rbegin(); arr.rend(); arr.cbegin(); arr.cend(); arr.size(); arr.front(); arr.back(); int data = std::get&lt;2&gt;(arr); arr.e...
STL练习题：Delivery
_Previous的博客
06-03 934
Description 快递公司在运送货物的时候，会通过机器扫描得到货物信息。但由于网络问题或重复扫描等问题，会产生冗余信息。现在需要根据接收到的信息，进行整理并按时间排序，去除掉多余信息。信息方式：YYYY/MM/DD-HH:mm:ss|快递信息要求保留某“快递信息”最早记录。按时间顺序进行排序。月：1-12日：1-30时：0-23分、秒：0-59输出格式YYYY/MM/DD-HH:mm:ss
读c++ primer有感——stl性能leetcode刷题直观测试
liu3daniel的博客
05-08 1208
用leetcode刷题对stl效率的感性认识。期望证实即使对stl（或某些c++特性）即使在不熟练的应用下也和裸写c没有性能代差（就是有差距也是小系数线性的），后面的文章会用string源码为例剖析下stl的实现细节和性能，而本文只是个简单的事实堆砌。 ps：stl网上有不少说法，这里就取standard template library的本意，用模板实现的那部分容器算法迭代器和各种trait都
stl 声音传递损失测试
最新发布
11-23
STL 声音传递损失测试是用来评估声音在传播过程中的能量损失情况。这项测试通常用于评估声音在建筑物、隔音墙、隔音窗等结构中的传递损失情况。测试的目的是为了确定声音在传播过程中经过不同结构或材料时的衰减程度，从而帮助人们更好地设计和建造隔音设施。 测试过程通常包括在发出一定强度的声音信号后，测量声音在传播过程中的衰减程度。这通常涉及到在不同位置使用特定的音频设备和传感器来测量声音的强度，然后通过分析数据来确定声音在传播过程中的损失情况。 STL 声音传递损失测试对于在需要有效隔音的场所，比如录音棚、剧院、医院、学校等场所非常重要。通过了解声音在传播过程中的损失情况，人们可以采取相应的措施来改善隔音效果，比如调整材料、增加隔音层、改善结构以及改进设计等方式来减少声音损失，从而提高建筑物的隔音效果。 总的来说，STL 声音传递损失测试是非常重要的，它可以帮助人们了解声音在传播过程中的损失情况，从而指导设计和建造隔音设施，提高建筑物的隔音效果。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值