各种注意事项（还有c++的一些操作）

转c++时间：

2017年8月9号

1、记得打头文件

2、=与==的区别（赋值|比较）

3、各种运算符的比较级（与Pascal不同），主要是==与位运算

*4、在OJ上scanf和printf时间优于cin、cout，但是在c++上差不多

5、用define定义max和min会更快

这样写：

#define min(x,y) (x<y?x:y)
#define max(x,y) (x>y?x:y)

其实用define定义大多数东西都要更快（比如lowbit）

如图



*6、c++一般爆变量范围和数组范围都不会提示，只是会搞出一些奇怪的结果。

7、c++数组下标最小为0。

8、在if中，可以用=来给变量赋值，不会判错，所以如果==打成=就会错。

9、c++用字符串前要加上using namespace std;

10、c++的字符&&字符串实际都是整数，即该字符的ascii码。

11、c++scanf输入时，变量前要加"&"。

12、c++scanf前要加"%"+该类型对应的字符，否则有可能会出错。

13、printf中\n是换行。

14、cout中 << endl是换行。

15、Pascal中exit是return，halt是exit。break、continue不变。

16、c++中for循环基本相当于pascal的while循环。

17、过程的类型是void。

18、一般来说，c++在代码长度和运行时间都优于Pascal。

*19、万能头文件：#include< bits/stdc++.h>

*20、手动O2：

_attribute_((optimize("-O2")))

加在主程序、子程序前

21、取消同步

ios::sync_with_stdio(false);

加完后可使cin、cout 接近 printf和scanf的速度。

*22、关于程序结尾加不加return 0

见此：https://zhidao.baidu.com/question/374166755.html

最好加上去。

*23、判断C++文件结束

和pascal大致，不过EOF(大写)是一个常量(一般是-1)：

当scanf(读入内容)==EOF时表示读到结尾。

见此：https://zhidao.baidu.com/question/393160350.html

*24、C++关闭文件

fclose(cstdin/cstdout);

noip中一定要关

25、C++中用Ctrl+/可以快速注释/恢复一行

方便很多

26、C++bitset用法

可以拿来进行二进制操作

见此：http://blog.csdn.net/qll125596718/article/details/6901935

27、C++快速读入

奇♂妙

inline int getint() { char c; int ret=0, k=1; for(c=getchar(); c<'0' || c>'9'; c=getchar()) if(c=='-') k=-1; for(; c>='0'&&c<='9'; c=getchar()) ret=ret*10+c-'0'; return k*ret; }

*28、register是好东西

在变量名前加register，跑得飞快

详细

29、c++自带的东西比一般的要快

不然你写的就会成为新的模板

话说之前听别人说c++的快排更慢于是打了将近一年的手打快排

30、FFT循环的顺序不同，在O2模式下时间差异很大

就像这两段代码：

void fft(C a[],int type)
{
	for (int i=0; i<N; i++) AA[i]=a[c[i]];
	for (int i=0; i<N; i++) a[i]=AA[i];

	for (int s=N>>1,S=2,S2=1,i=1; S<=N; i++,S2=S,s>>=1,S<<=1)
	{
		C W(Cos[i] , Sin[i]*type);

//		①
//		C w(1,0);
//		fo(j,0,S2-1)
//		{
//			for (l=j; l<N; l+=S)
//			{
//				u=a[l];v=w*a[l+S2];
//				a[l]=u+v;a[l+S2]=u-v;
//			}
//			w=w*W;
//		}

//		②
		for (l=0; l<N; l+=S)
		{
			C w(1,0);
			fo(j,0,S2-1)
			{
				u=a[l+j];v=w*a[l+j+S2];
				a[l+j]=u+v;a[l+j+S2]=u-v;
				w=w*W;
			}
		}
	}
}

①是先枚举每个段里的位置，然后一起算。

②是一个段一个段分开来搞。

测试结果发现②跑15000ms，①>20000ms

（bzoj3513: [MUTC2013]idiots）

(但不开O2似乎①更快些)

（可能是因为操作的区间连续？）

31、stable_sort要比sort更快

32、+比-快

33、c++的strlen慢到爆炸（时间与长度成正比）

34、函数记得带返回值（不然有可能本地是对的但交上去是错的）

c++会智能地帮你选一个值

*35、c++在本地的随机数范围是\(0\)到\(2^{15}-1\)，但在OJ上是\(0\)到\(2^{31}-1\)

http://172.16.0.132/senior/#main/show/3658

的惨痛经历

36、在switch中case :后直接按'{'会自动补上'break;'

37、FFT记得预处理\(\omega\)不然你会体会到什么是绝望

38、c++的除法慢得跟s*it一样，除法能预处理的尽量预处理

39、c++实用的快捷键

选中后按"/"可以整体注释or恢复

按Tab可以整体后移一个Tab，按住Shift+Tab可以整体前移一个Tab

选中后按"Shift"+"Ctrl"+上/下方向键可以整体上/下移

40、记得对拍

*41、善用c++的F5调试（尽管和Pascal的相比就是*）

42、在c++中一行一行复制（不全选）的话中文有概率（？）不会变成乱码

其实可以直接保存为txt然后复制

*43、大赛时一定要把所有头文件加上去（有可能编译错误但不提示）

44、用fread读入末尾记得加Ctrl+Z

45、后缀反过来=前缀，看到后缀不要只想到自动机

46、记得考虑特殊值（比如0）

47、类似求最优方案下的最坏可以考虑倒推

48、离散化方格时要考虑两个坐标之间有没有间隙，如果有要加上去

49、线段树合并时要直接合并对应节点，如果要从儿子向上合并可能会挂

49.5、如果一定要从儿子向上合并（如jzoj3397）的话要将最下面的点合并，并且update时要判断儿子是否存在（-2019年7月12日）

50、在树上dfs会爆栈的可以考虑bfs

51、用float时要注意精度

52、五年OI一场空，不开long long见祖宗

53、CF貌似不能用M_PI之类的东西

53.5、CF的long double好像只能用cout输出。。。

*54、用scanf读入bool类型貌似会挂（可以用int来存）

55、去重/维护栈可以在原数组上维护（省空间）

56、stable_sort有时比sort要快很多（但会占更多空间）

（因为stable_sort用的是归并排序，需要额外长度等于排序长度的空间）

详见https://zh.cppreference.com/w/cpp/algorithm/stable_sort

57、sap跑满后不立刻退出似乎会挂

58、网络流如果两个方向都有边，则可以建在一起（不建反向边），这样可以快一些

*59、关于memset的一些东西（整数与实数的区别）

#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#define fo(a,b,c) for (a=b; a<=c; a++)
#define fd(a,b,c) for (a=b; a>=c; a--)
using namespace std;

int a[1];
float b[1];

int main()
{
	memset(a,1,sizeof(a));printf("%d\n",a[0]);
	memset(a,127,sizeof(a));printf("%d\n",a[0]);
	memset(a,128,sizeof(a));printf("%d\n",a[0]);
	memset(a,255,sizeof(a));printf("%d\n",a[0]);

	memset(b,1,sizeof(b));printf("%0.20f\n",b[0]);
	memset(b,127,sizeof(b));printf("%0.20f\n",b[0]);
	memset(b,128,sizeof(b));printf("%0.20f\n",b[0]);
	memset(b,254,sizeof(b));printf("%0.20f\n",b[0]);

	memset(b,255,sizeof(b));printf("%0.20f\n",b[0]);
}

输出：

16843009

2139062143

-2139062144

-1

0.00000000000000000000

339615136492207134461438014706212143104.00000000000000000000

-0.00000000000000000000

-169473953031737902729750710990328037376.00000000000000000000

nan

结论：

c++中整数的赋值，127和128是极值，255是-1

而实数的赋值则是127和254是极值，1和128是清零，255是nan

60、如果要枚举每个数的因子，可以先枚举因子再枚举倍数，这样的时间约为O(n ln n)

61、可以在定义循环时加上register来加速：

#define fo(a,b,c) for (register int a=b; a<=c; a++)

（但这样a就是不是全局变量，值不会保留）

62、结构体的两种赋值方式

#include <iostream>
#include <cstdio>
#define fo(a,b,c) for (a=b; a<=c; a++)
#define fd(a,b,c) for (a=b; a>=c; a--)
using namespace std;

struct type{
	int x,y;
	type (){}//如果不加这一条，下面就要变成int _x=0,int _y=0
	type (int _x,int _y){x=_x,y=_y;}
} b;

int main()
{
	b=type{1,1};cout<<b.x<<" "<<b.y<<endl; //1 1  type可省略
	b=type(2,2);cout<<b.x<<" "<<b.y<<endl; //2 2
}

UPD:其实可以直接type a{...} 或 a={...}即可

63、bitset的时间为O(n/32)，空间为O(n/8)

64、用define时注意括号（因为是直接替换）

65、c++有log2，不用log(n)/log(2)

65.5、c++还有atan2(y,x)，可以直接求夹角...

65.5.5、atan2(y,x)在y<0时会有负数，但总体还是以x轴正半轴为0°逆时针旋转

*66、关于unsigned系列的右移问题

#include <algorithm>
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <cmath>
#define fo(a,b,c) for (a=b; a<=c; a++)
#define fd(a,b,c) for (a=b; a>=c; a--)
using namespace std;

unsigned int a;
unsigned long long b;

int main()
{
	a=2147483648ll;a>>=31;
	b=9223372036854775808ll;b>>=63;
	cout<<a<<" "<<b<<endl; //1 1

	a=2147483648ll;a>>=32;
	b=9223372036854775808ll;b>>=64;
	cout<<a<<" "<<b<<endl; //2147483648 9223372036854775808
}

可以发现，unsigned int右移32位 or unsigned long long右移64位时不会执行语句

67、查看程序时间

https://www.cnblogs.com/didiaodidiao/p/9194702.html

GetTickCount()，类型为DWORD

要加头文件<Windows.h>

68、bitset的_Find_next函数

作用是找下一个为1的位置

但是NOIP应该不能用

*69、求点双时的low要最后再赋值

其实在访问一个还在栈的点赋dfn，未被访问过的赋low即可（点or边双）

70、bfs记得扩展节点

*71、priority_queue的比较方式和set/sort相反（包括定义的结构体），因为设定上是大根堆

https://www.cnblogs.com/gmh77/p/11816070.html

*72、求强联通分量时更新low要判断是否在栈中，求点双/边双不用（无向图没有横插边）

*73、记得算空间是否超限（尤其是fread）

74、调试时可以在编译选项-编译器中加 -O2 ，如果答案变了就可能爆数组了

74.5、-O2不用记得关掉，否则调试时可能会出错

75、把编译器调为64位就可以用__int128了

NOIP应该布星

76、设断点时可以用n=n之类的东西，但是n必须要是全局变量

*77、

想到可能是正解的东西要谨慎考虑（正确性&时间），一定要打先部分分

要把有把握能过的点特判出来，避免被其它不确定算法影响

78、扫描线注意考虑x相等时插入&删除的先后顺序

79、dp维护总数和某种元素的个数可以维护差值（CSP2019D2T1）

80、线性基&异或高斯消元可以用bitset搞，n=3000照样过

81、stl的比较函数如果打挂了可能会出现奇怪的错误比如少了一个数之类的

可以开O2来检查

82、看到平面图就要想到转对偶图

83、维护凸壳时一定要注意边(t-1,t)的斜率存在t-1上

84、快排的参数是a+l和a+r+1，+1不能漏

85、调试的ifdef和endif（注意是两个if）

可以用

#ifdef xxx

#else

#endif xxx

来调试，要在头文件处加#define xxx，每次只需要注释掉这一行即可

86、c++的printf&cout是从右往左执行的

#include <bits/stdc++.h>
using namespace std;
int aaa(int t) {cout<<t<<endl;return 0;}
int main()
{
	cout<<aaa(1)<<" "<<aaa(2)<<endl;
	printf("%d %d\n",aaa(1),aaa(2));
}

输出：

2

1

0 0

2

1

0 0

87、splay记得在双旋、查找前下传标记，尤其是在有翻转标记的时候

88、c++的逗号是从左往右执行的，所以要注意语句的顺序

*89、CF的(正常)题一般都很短，在几十行左右，所以如果感到「不好写」那多半是写假了（或者不是最简单的做法）

90、构造题先考虑下界，如果能构造到下界就必定最优

*91、对拍时数据记得写随机种子（把srand放在最前面）

*92、调试小数据时不一定要答案错误，如果某个数组的值不对也有问题

93、平面图中的一个块内的答案可以在对偶图的以外边界所在区域为根的生成树上维护答案（根据内侧的点是父亲或儿子来加或减子树答案） --LOJ2052「HNOI2016」矿区

94、c++手动扩栈：编译选项加 -Wl,--stack=大小

95、读入优化要考虑负数

96、平面图满足 点数-边数+面数=2，边最多为3n-6，面最多为2n-4

https://www.cnblogs.com/lfri/p/9939463.html

97、stl的函数使用都有一定的时间（包括size、begin、top之类的，以及直接访问vector），如果可以最好存下来

98、map与vector

map:https://blog.csdn.net/sevenjoin/article/details/81943864

vector:https://blog.csdn.net/shuoyueqishilove/article/details/80431927

有邻接表用什么vector?

真香

99、交互题调试：手动模拟交互库，如果询问固定了的话就可以用文件调试

通信题如果没有下发调试工具就只能肉查了

100、splay的size要加上自己，维护序列加上首尾节点，找前驱后继要考虑情况

101、一条路径u-v经过一条边x-y(fa[y]=x)，等价与子树y内只有一个该路径中的端点，即

min(bg[u],bg[v])<bg[y],bg[y]<=max(bg[u],bg[v])<=ed[y]

或

bg[y]<=min(bg[u],bg[v])<=ed[y],ed[y]<max(bg[u],bg[v])

*102、函数记得return

103、按秩合并不用路径压缩

104、差分约束系统无解：最短路负环 or 最长路正环

105、FFT的优化：1.预处理翻转 2.预处理sincos 3.把要多次加在一起的最后再IDFT 4.换NTT 5.换FHT

106、exgcd找到的是两组绝对值最小的中的一组，所以当ab互质时把x变号只需±ab即可

107、c++中的log()是ln，log10()是log10

108、NTT中的a[js1+k+s2]w不需要模（mod=998244353时）

109、pollard rho优化

https://www.cnblogs.com/812-xiao-wen/p/10544546.html

109.5、pollard rho的一些操♂作

①当n很小时可以预处理直接分解

②可以把小的质因子删去后对n'记忆化（针对n=p*q的情况）

110、&&与&的区别

a&&b&&c，当a不成立时bc不会执行

a&b&c，当a不成立时bc仍会执行

||与|同理

111、O(1)快速乘

long long mul(long long a,long long b,long long mod)
{
	return ((a*b-(long long)((long double)a/mod*b)*mod)%mod+mod)%mod; //O(1)
}

https://blog.csdn.net/qq_40507857/article/details/82110505

https://blog.csdn.net/weixin_33828101/article/details/94706148

112、map可以直接用a[x]=y来操作

a[2];
I=a.find(2);
cout<<(I==a.end())<<endl;

结果是0，也就是说只要提到了a[x]，那么a[x]就会被创建

113、当n很大时要用输出优化

114、NTT一个周期为(mod-1)

*115、scanf不能直接读bool类型

*116、矩乘小技♂巧：多组数据+固定矩阵时，可以预处理矩阵的幂，之后用一维乘二维（一次乘法可以变成m^2）

117、注意tarjan跑完后根节点可能还有剩余，而且还要注意自环

118、分治题&线段树注意区间为空的情况

119、注意线段树标记下传时判断的是(len>1)而不是(len)

120、关于循环对时间的影响

https://www.cnblogs.com/gmh77/p/12392514.html

121、线段树分治记得反着退

122、随机排列生成方法：维护剩余的数，每次随机完用最后一个换掉

123、区间数字出现次数为奇数：随机一个值，出现的xor和=区间xor和

*124、结束前一定要留时间检查文件输入输出

125、线段树动态开点可以做到复制整棵树（前提是修改的总点数不多），可能的话要开大一些

*126、一定要测极限&特殊数据

127、对一个数不断取gcd，变化量只有log（每次减一半）

128、期望一般考虑逆推，即求出每个状态到终点的答案

*129、函数内变量要清零

130、循环不要写反for (初始;条件;步进)

131、可以用 ::变量名 来表示全局变量

132、F5调试时要关O3和c++11，否则可能会挂掉

*133、同一条式子里一个变量出现多次就不要用++--，本地和实际评测结果可能不一样

134、当给出的状态在一个范围内随机时：维护范围

135、SAM当len[u]+1<len[v]时复制后要把前面所有连向v值为c的边修改（必然是一个连续段），编号可能小->大（不能直接扫求倍增，可以在dfs时求）

136、burnside/polya加上限制条件后仍可以用，只需要保证循环节为x的在kx被算x次即可，每段的方案可以考虑矩乘

137、不要直接把.size()丢到循环里

138、stl常数巨大

138.5、活用暴力，有时会有意想不到的收获

139、质因数分解&算phi时及时退可以省时间

*140、线段树区间修改+求和记得乘上区间长

update:在写下这句话之后就忘了乘

141、树上连通块计数：点-边=1

142、

int a[233];
void work(int *a)
{
	cout<<sizeof(a)<<endl;
	cout<<sizeof(::a)<<endl;
}
int main() {work(a);}

输出：

8

932

要注意 数组 的初值赋法

143、树剖一定要在同一条链上时才能直接修改（而不只是有祖先关系）

144、子树（非整棵树）计数：度数=2点数-1，∑2-度数=1

145、点分治如果中心找错了会T但是不会WA

146、两个长度为n的多项式卷积一定要开到2n

147、min25不加p^2<=n就会变成O(n)

c++头文件

精简版

#include <algorithm>
#include <iostream>
#include <cstdlib>
#include <cstdio>
#define fo(a,b,c) for (a=b; a<=c; a++)
#define fd(a,b,c) for (a=b; a>=c; a--)
using namespace std;

int main()
{
	freopen("文件名.in","r",stdin);
	freopen("文件名.out","w",stdout);

	fclose(stdin);
	fclose(stdout);

	return 0;
}

完整版

#include <bits/stdc++.h>
#include <algorithm>
#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
#define fo(a,b,c) for (a=b; a<=c; a++)
#define fd(a,b,c) for (a=b; a>=c; a--)
using namespace std;
__attribute__((optimize("-O2")))
inline int getint() { char c; int ret=0, k=1; for(c=getchar(); c<'0' || c>'9'; c=getchar()) if(c=='-') k=-1; for(; c>='0'&&c<='9'; c=getchar()) ret=ret*10+c-'0'; return k*ret; }

int main()
{
	ios::sync_with_stdio(false);

	freopen("文件名.in","r",stdin);
	freopen("文件名.out","w",stdout);

	fclose(stdin);
	fclose(stdout);

	return 0;
}

O3系列

#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")