关于C++的各种卡常技巧

卡常

在OI之路中，我们做题目时经常预计时间能过得去，但是却会被卡掉，那是因为我们程序的常数太大，所以今天来教一教大家如何减小常数，达到卡常的效果。

读入优化

这个相信大家都很熟悉。

char c;
int s;
int fastread()
{
	s=c=0;
	while(c<'0'||c>'9') c=getchar();
	while(c>='0'&&c<='9')
	{
		s=s*10+c-'0';
		c=getchar();
	}
	return s;
}

register优化

register其实就是寄存器的意思。
平时定义临时变量的时候用register可以加快速度。
就比如说大家都喜欢写for(int i=1;i<=n;i++)
其实这样写更快：for(register int i=1;i<=n;i++)
当然，大多人还是习惯第一种，不过我们可以在写完程序后干这么一件事情。
按下Ctrl+Shift+R，会出现这样的界面：

然后在搜索“”里面输入for(int
“替换为”里面输入for(register int，像这样：

然后就可以啦。

吸氧大法(又称火车头，慎用)

#pragma GCC optimize(2)
#pragma GCC optimize(3)
#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")

精简版火车头（经本人研发）

#pragma GCC optimize(2)
#pragma GCC optimize("inline")

短整型（字符型）卡常

众所周知，一个 int 类型的变量占4个字节，一个short类型的变量只占两个字节。理论上来说，short类型之间的运算速度是int类型之间的运算速度的$\frac{1}{2}$，换句话说，如果这一道题变量开short能过的话，那么你可以选择开short，当然，char类型也是一个不错的选择（如果存得下的话）

另外提醒一句，我们是为了提高分数而卡常，千万不要因为开成了short而丢分。

压位

如果考试的时候给的序列中的数比较小，或者是一个01序列，那么可以考虑把多个数压到一个数位上。记得提前预处理一下，会快很多哟。

循环展开

这个比较神奇。

比如说一个程序，原本时间复杂度是$O(n^2)$，但是如果你用一些高科技（如循环展开）也许能够跑完$3\times 10^4$的数据哦。

比如说

#include<cstdio>
#include<ctime>
using namespace std;
int a[100000010];
int main()
{
	int n=1e8;
	for(int i=1;i<=n;i+=4)
	{
		a[i]++;
		a[i+1]++;
		a[i+2]++;
		a[i+3]++;
	}
	printf("%d",clock());
}

最后的 clock() 函数会输出程序运行的时间（一般来说看运行完后显示的时间不是最标准的，OJ一般就按 clock() 的时间来算）

显然，这比直接 for(int i=1;i<=n;i++) a[i]++; 快了一些。

下标连续访问

#include<cstdio>
#include<ctime>
using namespace std;
int a[100000010];
int main()
{
	int n=1e8;
	for(int i=n;i;i--) a[i]++;
	printf("%d",clock());
}

#include<cstdio>
#include<ctime>
using namespace std;
int a[100000010];
int main()
{
	int n=1e8;
	for(int i=1;i<=n;i++) a[i]++;
	printf("%d",clock());
}

这两份代码时间有差别，因为第二份的下标是从小到大连续访问的，会更快些，这东西如果运用到矩阵乘法内，可以让矩阵乘法原地起飞。