C++的速度优化

博客园的博客
注$:⨁$是异或的意思$($^$)$，$\ll n$为二进制左移$n$位,$\gg n$为二进制右移$n$位。
起因——————
中国近现代史上伟大的爱国者、伟大的革命家与改革家、伟大的民主主义者、伟大的启蒙思想家陈独秀曾经说过：
“只有两位先生才能拯救我们。”
一位叫$T$先生$(TLE[TimeLimitExceeded])$，另一位叫$W$先生$(WA[WrongAnswer])$。
在现实中，$WA$可以很快改正，而$TLE$——

呵呵
那让我们谈谈代码中的优化

1.快速结束程序

#include<cstdlib>//所需头文件
exit(0);//退出程序，结束运行

免得退出导致超时
例如$——$

#include<cstdio>
void dfs5()
{
	exit(0);
	while(1)new int;
}
void dfs4()
{
	dfs5();
	while(1)new int;
}
void dfs3()
{
	dfs4();
	while(1)new int;
}
void dfs2()
{
	dfs3();
	while(1)new int;
}
void dfs1()
{
	dfs2();
	while(1)new int;
}
int main()
{
	dfs1();
	while(1)new int;
}

可以退出其他递归，保证不会陷入$while(1)$里面。

2.register

$register$修饰符暗示编译程序相应的变量将被频繁地使用，如果可能的话，应将其保存在$CPU$的寄存器中，以加快其存储速度。

3.inline

$inline$定义的类的内联函数，函数的代码被放入符号表中，在使用时直接进行替换，（像宏一样展开），没有了调用的开销，效率也很高。

4.位运算

因为电脑是二进制，所以用二进制的位运算会比十进制的加减乘除快得多
$x\times 10\to (x\ll 3)+(x\ll 1)$
$x̸=y$$\to bool(x⨁y)$
$x̸=-1\to bool(\sim x)$
$x\times 2\to x\ll 1$
$x\times 2+1\to x\ll 1|1$
$x÷2\to x\gg 1$
$(x+1)\%2\to bool(x⨁1)$
$x\%2\to$$x\&1$
为什么要加$bool$呢？
因为$̸=$和$\%2$只有$1$和$0$这两个返回值，就是$bool$类型。
而$⨁$有多种返回。
在$a[x̸=y]$中，直接转成$a[x⨁y]$可能会导致$RE$
例如

#include<cstdio>
char a[2][5]={"YES","NO"};
int main()
{
	int x,y;scanf("%d%d",&x,&y);
	puts(a[x!=y]);
}

如果直接转换，将会出现以下情况

#include<cstdio>
char a[2][5]={"YES","NO"};
int main()
{
	int x,y;scanf("%d%d",&x,&y);
	puts(a[x^y]);
}

明显当$x$和$y$选一些值就卡掉了$(1,2)$

5.少用或不用STL

这里要提到一个万恶的头文件

#include<algorithm>

其中有两个函数，叫$max$和$min$。
速度慢，是$STL$的天生一大劣势。
$\max$和$\min$比$a>b?a:b$和$a<b?a:b$慢好几倍
除了$sort$（快速排序）和$priority$_$queue$（堆排序）这种比较难不用$STL$的这种以外尽量少用
比如

void swap(int &x,int &y){int t=x;x=y;y=t;}
swap(a,b);

再比如

inline int mymax(int x,int y){return x>y?x:y}//等于STL的max
inline int mymin(int x,int y){return x<y?x:y}//等于STL的min

$x>y?x:y$意思是
如果$x>y$那么着整个式子表示$x$，不然表示$y$。
（如果想用且想快，请见其他里的氧气）

6.快读快写

当然不能少这个啦
先给大家一个东西

准备工作

计算时间

#include<cstdio>
#include<ctime>
using namespace std;
int main()
{
	clock_t start,finish;
	double totaltime;
	start=clock();
	
	//.......     放代码
	
	finish=clock();
	totaltime=(double)(finish-start)/CLOCKS_PER_SEC;
	printf("此程序的运行时间为%.36lf秒！\n",totaltime);
}

用于运行计算时间，精度可以自己调 （其实是抄来的）

随机数

还有随机数

#include<ctime>
#include<cstdio>
#include<algorithm>
using namespace std;
int main()
{
	srand((unsigned)time(NULL));//以时间作为种子
	//如果没加srand，在一次运行中就会输出一样的数
	//只需写srand(time(0))
	printf("%d\n",rand());
	/*rand()生成随机数，上限32767，若要取a~b之间的随机数，格式为rand()%
(b-a+1)+a*/
}

超慢cin cout

乌龟都比$cin$和$cout$快，尤其是$cin$
除了万不得已千万别用
如习惯用了，就加上这个
ios_base::sync_with_stdio(0);
之后就不要能$scanf$和$printf$了

#include<ctime>
#include<cstdio>
#include<cstdlib>
#include<iostream>
#define R register
#define ri R int
#define rep(a,b,c) for(ri a=b;a<=c;++a)
using namespace std;
int main()
{
	freopen("a.out","w",stdout);
	srand((unsigned)time(NULL));
	clock_t start,finish;
	double totaltime;
	start=clock();
	ri x;
	rep(i,1,1000000)cout<<rand()<<endl;
	finish=clock();
	totaltime=(double)(finish-start)/CLOCKS_PER_SEC;
	printf("此程序的运行时间为%.36lf秒！\n",totaltime);
	//此程序的运行时间为3.625000000000000000000000000000000000秒！
}

慢的抠脚

#include<ctime>
#include<cstdio>
#include<cstdlib>
#include<iostream>
#define R register
#define ri R int
#define rep(a,b,c) for(ri a=b;a<=c;++a)
using namespace std;
int main()
{
	freopen("a.out","r",stdin);
	srand((unsigned)time(NULL));
	clock_t start,finish;
	double totaltime;
	start=clock();
	ri x;
	rep(i,1,1000000)cin>>x;
	finish=clock();
	totaltime=(double)(finish-start)/CLOCKS_PER_SEC;
	printf("此程序的运行时间为%.36lf秒！\n",totaltime);
	//此程序的运行时间为3.406000000000000138555833473219536245秒！
}

输出

从输出讲起
我们来尝试输出$100$万个数字

原始输出

#include<cstdio>
#include<ctime>
#include<algorithm>
#define R register
#define ri R int
#define rep(a,b,c) for(ri a=b;a<=c;++a)
using namespace std;
int main()
{
	freopen("a.in","r",stdin);
	freopen("a.out","w",stdout);
	srand((unsigned)time(NULL));
	clock_t start,finish;
	double totaltime;
	start=clock();
	rep(i,1,1000000)printf("%d\n",rand());
	finish=clock();
	totaltime=(double)(finish-start)/CLOCKS_PER_SEC;
	printf("此程序的运行时间为%.36lf秒！\n",totaltime);
	//此程序的运行时间为3.406000000000000138555833473219536245秒！
}

初级快写

用上快写

#include<cstdio>
#include<ctime>
#include<algorithm>
#define li inline
#define gc getchar
#define pc putchar
#define R register
#define ri R int
#define rd R double
#define rb R bool
#define rc R char
#define LL long long
#define rl R LL
#define wr(n) write(n,false),pc('\n')
#define rep(a,b,c) for(ri a=b;a<=c;++a)
using namespace std;
li void write(rl ans,rb bk)
{
    if(ans<0)pc('-'),ans=-ans;
    if(ans==0)
    {
        if(!bk)pc('0');
        return ;
    }
    write(ans/10,true);
    pc(ans%10^'0');
}//这里是递归式，还有不用递归式的
int main()
{
	freopen("a.in","r",stdin);
	freopen("a.out","w",stdout);
	srand((unsigned)time(NULL));
	clock_t start,finish;
	double totaltime;
	start=clock();
	rep(i,1,1000000)wr(rand());
	finish=clock();
	totaltime=(double)(finish-start)/CLOCKS_PER_SEC;
	printf("此程序的运行时间为%.36lf秒！\n",totaltime);
	//此程序的运行时间为0.623999999999999999111821580299874768秒！
}

高级快写

然而还可以更快
因为$0$的$ASCII$码为$48,9$为$57$
转化为2进制为
$110000$
就是
$32\ast 1+16\ast 1+8\ast 0+4\ast 0+2\ast 0+1\ast 0=48$
可以用异或来加上（或消去）48，而异或比减法快得多
$000000(0)⨁110000(48)$得到$110000{(}^{\prime }{0}^{\prime })$
$000001(1)⨁110000(48)$得到$110001{(}^{\prime }{1}^{\prime })$
$000010(2)⨁110000(48)$得到$110010{(}^{\prime }{2}^{\prime })$
$000011(3)⨁110000(48)$得到$110011{(}^{\prime }{3}^{\prime })$
$000100(4)⨁110000(48)$得到$110100{(}^{\prime }{4}^{\prime })$
$000101(5)⨁110000(48)$得到$110101{(}^{\prime }{5}^{\prime })$
$000110(6)⨁110000(48)$得到$110110{(}^{\prime }{6}^{\prime })$
$000111(7)⨁110000(48)$得到$110111{(}^{\prime }{7}^{\prime })$
$001000(8)⨁110000(48)$得到$111000{(}^{\prime }{8}^{\prime })$
$001001(9)⨁110000(48)$得到$111001{(}^{\prime }{9}^{\prime })$

#include<cstdio>
#include<ctime>
#include<algorithm>
#define li inline
#define gc getchar
#define pc putchar
#define R register
#define ri R int
#define rd R double
#define rb R bool
#define rc R char
#define LL long long
#define rl R LL
#define wr(n) write(n,false),pc('\n')
#define rep(a,b,c) for(ri a=b;a<=c;++a)
using namespace std;
li void write(rl ans,rb bk)
{
    if(ans<0)pc('-'),ans=-ans;
    if(ans==0)
    {
        if(!bk)pc('0');
        return ;
    }
    write(ans/10,true);
    pc(ans%10^'0');
}
int main()
{
	freopen("a.in","r",stdin);
	freopen("a.out","w",stdout);
	srand((unsigned)time(NULL));
	clock_t start,finish;
	double totaltime;
	start=clock();
	rep(i,1,1000000)wr(rand());
	finish=clock();
	totaltime=(double)(finish-start)/CLOCKS_PER_SEC;
	printf("此程序的运行时间为%.36lf秒！\n",totaltime);
	//此程序的运行时间为0.577999999999999958255614274094114080秒！
}

输入

现在来看快读

原始输入

#include<cstdio>
#include<ctime>
#include<algorithm>
#define R register
#define ri R int
#define rep(a,b,c) for(ri a=b;a<=c;++a)
int main()
{
	freopen("a.in","r",stdin);
	srand((unsigned)time(NULL));
	clock_t start,finish;
	double totaltime;
	start=clock();
	int a;rep(i,1,1000000)scanf("%d",&a);
	finish=clock();
	totaltime=(double)(finish-start)/CLOCKS_PER_SEC;
	printf("此程序的运行时间为%.36lf秒！\n",totaltime);
	//此程序的运行时间为1.655999999999999916511228548188228160秒！
}

直接用$scanf$，输入100万个数已经超时

初级快读

利用$getchar$比$scanf$快得多的特性
加上前面提到的异或的

#include<ctime>
#include<cstdio>
#include<algorithm>
#define li inline
#define gc getchar
#define R register
#define ri R int
#define rc R char
#define LL long long
#define rep(a,b,c) for(ri a=b;a<=c;++a)
li LL read()
{
    ri x=0,f=1;rc ch=gc();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=gc();}
    while(ch>='0'&&ch<='9')x=x*10+(ch^48),ch=gc();
    return x*f;
}
int main()
{
	freopen("a.in","r",stdin);
	srand((unsigned)time(NULL));
	clock_t start,finish;
	double totaltime;
	start=clock();
	int a;rep(i,1,1000000)qr(a);
	finish=clock();
	totaltime=(double)(finish-start)/CLOCKS_PER_SEC;
	printf("此程序的运行时间为%.36lf秒！\n",totaltime);
	//此程序的运行时间为0.420999999999999985345056074947933666秒！
}

中级快读

然而$x\times 10$还可以转化为$(x\ll 3)+(x\ll 1)$

#include<ctime>
#include<cstdio>
#include<algorithm>
#define li inline
#define gc getchar
#define R register
#define ri R int
#define rc R char
#define LL long long
#define rep(a,b,c) for(ri a=b;a<=c;++a)
li LL read()
{
    ri x=0,f=1;rc ch=gc();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=gc();}
    while(ch>='0'&&ch<='9')x=(x<<3)+(x<<1)+(ch^48),ch=gc();
    return x*f;
}
int main()
{
	freopen("a.in","r",stdin);
	srand((unsigned)time(NULL));
	clock_t start,finish;
	double totaltime;
	start=clock();
	int a;rep(i,1,1000000)qr(a);
	finish=clock();
	totaltime=(double)(finish-start)/CLOCKS_PER_SEC;
	printf("此程序的运行时间为%.36lf秒！\n",totaltime);
	//此程序的运行时间为0.406000000000000027533531010703882203秒！
}

高级快读

$\mid$和$?:$还是比$if$和$\times$快的

#include<ctime>
#include<cstdio>
#include<algorithm>
#define li inline
#define gc getchar
#define R register
#define ri R int
#define rc R char
#define LL long long
#define rep(a,b,c) for(ri a=b;a<=c;++a)
li LL read()
{
    ri x=0,f=0;rc ch=gc();
    while(ch<'0'||ch>'9')f|=ch=='-',ch=gc();
    while(ch>='0'&&ch<='9')x=(x<<3)+(x<<1)+(ch^48),ch=gc();
    return f?-x:x;
}
int main()
{
	freopen("a.in","r",stdin);
	srand((unsigned)time(NULL));
	clock_t start,finish;
	double totaltime;
	start=clock();
	int a;rep(i,1,1000000)qr(a);
	finish=clock();
	totaltime=(double)(finish-start)/CLOCKS_PER_SEC;
	printf("此程序的运行时间为%.36lf秒！\n",totaltime);
	//此程序的运行时间为0.406000000000000027533531010703882203秒！
}

这就差不多了

神一般的快读快写

但还有更快的
不要以为$getchar,putchar$是最快的，利用$fread,fwrite$会更快，但风险很大，很多$oj$上不能用，需要$freopen$才能使用，不会在运行是输出，全都保存在一个文件里

里面长这样

一堆乱码
不过很快

#include<cstdio>
#include<ctime>
#include<algorithm>
#define li inline
#define gc getchar
#define R register
#define ri R int
#define rd R double
#define rb R bool
#define rc R char
#define LL long long
#define rl R LL
#define wr(n) write(n,false),pcf('\n')
#define rep(a,b,c) for(ri a=b;a<=c;++a)
using namespace std;
const int chargs=1000000;//要输出多少的字符，就就把这个改为多少
li void pcf(rc c)
{
    static char duf[chargs],*q1=duf;
    q1==duf+chargs&&fwrite(q1=duf,1,chargs,stdout),*q1++=c;
}
li void write(rl ans,rb bk)
{
    if(ans<0)pcf('-'),ans=-ans;
    if(ans==0)
    {
        if(!bk)pcf('0');
        return ;
    }
    write(ans/10,true);
    pcf(ans%10^'0');
}
int main()
{
	freopen("a.in","r",stdin);
	freopen("a.out","w",stdout);
	srand((unsigned)time(NULL));
	clock_t start,finish;
	double totaltime;
	start=clock();
	rep(i,1,1000000)wr(rand());
	finish=clock();
	totaltime=(double)(finish-start)/CLOCKS_PER_SEC;
	printf("此程序的运行时间为%.36lf秒！\n",totaltime);
	//此程序的运行时间为0.265000000000000013322676295501878485秒！
}

#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<ctime>
#define li inline
#define gc getchar
#define R register
#define ri R int
#define rc R char
#define LL long long
#define rl R LL
#define wr(n) write(n,false),pcf('\n')
#define rep(a,b,c) for(ri a=b;a<=c;++a)
using namespace std;
const int chargs=1000000;
li char gcf()
{
    static char buf[chargs],*p1=buf,*p2=buf;
    return (p1==p2&&(p2=(p1=buf)+fread(buf,1,chargs,stdin),p1==p2)?EOF:*p1++);
}
li LL read()
{
    rl x=0,f=0;rc ch=gcf();
    while(ch<'0'||ch>'9')f|=ch=='-',ch=gcf();
    while(ch>='0'&&ch<='9')x=(x<<3)+(x<<1)+(ch^48),ch=gcf();
    return f?-x:x;
}
int main()
{
	freopen("a.out","r",stdin);
	srand((unsigned)time(NULL));
	clock_t start,finish;
	double totaltime;
	start=clock();
	ri x;
	rep(i,1,1000000)qr(x);
	finish=clock();
	totaltime=(double)(finish-start)/CLOCKS_PER_SEC;
	printf("此程序的运行时间为%.36lf秒！\n",totaltime);
	//此程序的运行时间为0.061999999999999999555910790149937384秒！
}

这才是快读快写的真实水平

对比

输入速度

$cin$运行时间为$3.406000000000000138555833473219536245$秒
$scanf$运行时间为$1.655999999999999916511228548188228160$秒
初级快读运行时间为$0.420999999999999985345056074947933666$秒
中级快读运行时间为$0.406000000000000027533531010703882203$秒
高级快读运行时间为$0.406000000000000027533531010703882203$秒
神一般的快读运行时间为$0.061999999999999999555910790149937384$秒

输出速度

$cout$运行时间为$3.625000000000000000000000000000000000$秒
$printf$运行时间为$3.406000000000000138555833473219536245$秒
初级快写运行时间为$0.623999999999999999111821580299874768$秒
高级快写运行时间为$0.577999999999999958255614274094114080$秒
神一般的快写运行时间为$0.265000000000000013322676295501878485$秒

7.小技巧

非常小的优化也不能放过
$++i$比$i++$要快一些
定义数组时，大的尽量放前面

8.const

并不是所有优化都是运行时间上的优化，打代码时间减少也算优化
$const$为常量，从开始就要被赋值，之后不变。
定义同样大数组时，可以先用定义一个常量，然后将常量放到数组里
例如我们要定义一堆容量为$41000$的数组

const int N=41000;
int a[N],b[N],c[N],d[N],e[N]/*······*/;

可节省打代码的时间。

9.宏定义

比$const$快，可以代替冗长的东西，比如上文提到的$getchar$我是用宏定义将$getchar$定义成$gc$。
上面提到$inline$可以像宏一样展开，就是将在下面代码出现的同样的东西转化成定义的东西
格式

#define+空格+要转化的东西+空格+被转化的东西（可以中间带空格）

例如

#define LL long long

代表将出现$LL$的地方转化成$longlong$
是全字匹配
可以这样

#define R register
#define ri R int

不会编译错误
可以里面又带权值的东西
例如上文的$mymax$和$mymin$可以写成

inline int mymax(int x,int y){return x>y?x:y}
inline int mymin(int x,int y){return x<y?x:y}

还可以写成

#define mymax(a,b) a>b?a:b
#define mymin(a,b) a<b?a:b

举个栗子

#define mymax(a,b) a>b?a:b
#define mymin(a,b) a<b?a:b
int x,y,a,b;
a=mymax(x,y);b=mymax(x,y);

等于

a=x>y?x:y;b=x<y?x:y;

再比如

#define rep(a,b,c) for(int a=b;a<=c;++a)
rep(i,1,n)

等于

for(int i=1,i<=n;++i)

比加了$inline$的函数快，简单的东西可以代替。

不过，也要承担很大的风险
因为是直接展开，所以可能会因为运算符的优先级而导致错误
例如

#define po(n) 1<<n //求2的n次方
printf("%d",po(4)+1);

你希望的肯定是输出$17,$但是它所输出的是$32,$因为它展开后是

printf("%d",1<<4+1);

由上表得知，$+$的在$\ll$前运算
所以运算一次后就得

printf("%d",1<<5);

当然输出$32$啦
尽量在上面加括号

#define po(n) (1<<n)

其他（48行优化代码）

（慎用）

#pragma GCC target("avx")//AVX指令集(不懂的去问度娘)
#pragma GCC optimize(2)//吸氧气(O2)
#pragma GCC optimize(3)//吸臭氧(O3)
#pragma GCC optimize("Ofast")//吸更高质量的氧(优化到破坏标准合规性的点)，
#pragma GCC optimize("inline")//至于其他的我就不懂了
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")

能加速很多
但明显像NOIP这类比赛不能用