ACM 大神的经验加技巧（当然不是我的拉——

大神

犯错合集及需要注意的东西

1、在一个地图求最大面积的类问题中，要注意障碍结点的影响。

2、ll()，表示的是在运算后把括号内强制转化为类型ll，而(ll)表示后面的每个玩意都强制转化为类型ll。在做历史研究这道题时我WA就是因为我用的是ll()而不是(ll)。

3、splay每次splay操作后一定要记得更新root！

4、可以使用树状数组就尽量不要使用线段树。在Gty的文艺妹子序列这道题本机测试极限数据，线段树15s而树状数组4s，差距真大。

5、不需要开long long的就不要开long long。

6、分块算法，一定要特判两个端点之间没有跨过任意整一块的情况。

7、使用问号语句记得括号，不然会出错例如：

(ll)dp[i-1]*i%mo+(i%2)?-1:1

得到的值只有-1或1。

正确打法：

(ll)dp[i-1]*i%mo+((i%2)?-1:1)

• 1

8、不要主观臆断认为一个算法会TLE

9、点分治第0层不需要减去非法答案。（注意是第0层）

10、能打普通网络流不要随便上匈牙利

11、尽量提高算法的鲁棒性

12、有模运算的题目通常为了减少运行时间保留负数，这时将一个数t取反直接t=-t不要t=mo-t

13、使用肉眼检查程序时注意以下几点：

检查空间是否爆炸（很关键的第一步）

对应着题目的数据范围，一个个思考每个数组的意义以及大小是否开够 
同样要思考每个变量的范围，看看类型是否开够了，有时候会爆long long时考虑double 
然后重新过一遍代码， 认真的再思考，去检查每一个模块，尤其是要对乘法之类的敏感，思考会不会爆类型 
对于要初始化的部分，看看是否记得初始化需要使用的东西，初始化的范围是不是对的，如果用到了极值inf之类的仔细算inf是否就是极值，同时堤防inf是否过大以至于参与各种运算时爆类型 
最后检查一下定义的常数（如maxn），对照题目检查模数（不要被10^8+7坑），检查文件名和输入输出（输入是否能合法读进来，输出会不会格式错误）

14、不要用%lld输出int类型！

15、单调队列优化时，任何时候特别是转移时要注意队列内是否有元素。

16、不要写反n和m。出数据对拍时多注意出n不等于m的情况，n>m和n<mn<m都最好出一下。肉眼检查时同样需要特别注意这个问题。

17、处理树的问题时，一定要记住父亲编号比儿子编号大的情况可不可能使自己程序出错。

18、正解程序与暴力程序的共用部分，要好好检查，不然出了错都不知道自己怎么死的。

19、对于很难出数据或出的数据通常较水的情况，更加应该思考使用肉眼检查+小数据来检查程序。

20、即使是暴力，也要出极限数据去看会不会超时

21、splay使用旋法提取[l,r]需要特判l=r的情况。

做题套路以及一些东西

0、以下可能逻辑不通QAQ，都是归纳的一些idea啦。

1、字符串中的最长延伸问题可以用二分+哈希解决。

2、树的同构——有根树采用最小表示法，子树按照大小排列。无根树找到重心转化为有根树。

3、网络流用连边表示一种约束，然后如果约束最后形成二分图，即可用最小覆盖或最大独立解决。

4、期望的线性性：和的期望=期望的和

5、字符串的性质：求一个长度最小的T使得在S后补一些字符所得到的字符串存在循环节为T。那么答案为|S|-|next(S)|，next是KMP指针。

6、要求一个f[i]，f[i]只与前i-1相关，则可以考虑CDQ算法

7、求LCS的另一种dp，f[i,j]表示a的前i项选一个和b的第j项作为最后一次匹配的最大长度。f[i,j]=max(f[i-1,k])，视情况+1。

8、如果建了广义后缀树，可以用线段树合并的方法得到每个状态在多少个字符串中出现过，复杂度等同于字符串总长度log。

9、本质不同、本质步数之类的都好玄妙。例如一个数，不断整除，本质只会除log次就变成0了。

10、启发式合并是个好东西。例如这道题：求多少个(i,j)满足ai*aj<=max(ai~j)。首先建立笛卡尔树，枚举一个节点，变成统计左子树和右子树各挑一个，符合的个数。我们很容易想到暴力去做，即枚举两个子树中的一个。还可以想到一点优化，即枚举一个子树中的一个，另一个子树使用数据结构维护。然后发现，每次枚举较轻子树，复杂度与启发式合并一致！

11、如果能够证明相邻的偏序性，便可以通过传递性认为具有全局偏序性（纯口胡）

各种有用的东西、黑科技、技巧

1、整体二分及cdq分治实现时，每个区间不需要单独开队列。可以把操作弄到一个数组了，然后多两个参u、v表示这个区间的操作在u~v，做完后对每个操作打标记表示是否往右区间传即可。

3、unique()可以删除重复元素，然后返回删除重复元素后的末端地址。 
下面这段代码即可实现离散化。

fo(i,,n) scanf("%d",&a[i]),b[i]=a[i];
    sort(b+,b+n+);
    l=unique(b+,b+n+)-b-;
    fo(i,,n) a[i]=lower_bound(b+,b+l+,a[i])-b;

4、可以用调用ctime，运用clock（）获取程序运行至该语句时的时间（默认ms）

#include<iostream>
#include<ctime>
using namespace std;

int main()
{
    int n=;
    //start=clock();
    while(n<)
        n++;
    cout<<(double)clock()<<endl;
    return ;
}

5.调用头文件bits/stdc++.h就相当于包括了好多库……

6、如何打伪随机数？

int rand() {
    static int rand_seed=;
    rand_seed+=rand_seed<<|;
    return rand_seed;
}

8、关于可持久化，记住以下几点： 
1：一个点的信息要被修改时需要对其新建。 
为了节省空间，一个点的信息不被修改时就没必要新建了。 
例如合并一个结点与空节点，此时不需要新建。 
2：为了节省空间，如果对空节点进行newnode我们直接返回空节点（不适用任何可持久化数据结构，这条大概适用堆）。 
3：打标记也涉及修改信息，不要忘记newnode。而down的时候其实并不用，因为修改的是儿子的信息。 
9、从OJ上看来一句话，不知道来源。 
OI比赛的题目无非三种，从暴力到优化，从一般到特殊，重新定义题目。 
10、 FFT/NTT做题方法与调试技巧(+提高码题效率的一些想法) 
来自链接 
11、O(n)求出1~n对于质数MOD的逆元。 
来自链接 
inv[i] = ( MOD - MOD / i ) * inv[MOD%i] % MOD 
证明： 
设t = MOD / i , k = MOD % i 
则有 t * i + k == 0 % MOD 
有 -t * i == k % MOD 
两边同时除以ik得到 
-t * inv[k] == inv[i] % MOD 
即 
inv[i] == -MOD / i * inv[MOD%i] 
即 
inv[i] == ( MOD - MOD / i) * inv[MOD%i] 
证毕 
12、同时维护加法标记和赋值标记时，为了程序方便，可以把标记写为a*x+b的形式。同样，维护加法、赋值和取max标记可以把标记写为max(a+x,b)的形式。 
13、实现平衡树时，应该在x那加上&，注意rotate也需要。这样写最简单。

卡常及搜索优化技巧积累

1、求一个数的所有因数，可以暴力根号求，也可以分解质因数再用dfs组合而成。 
分解质因数时，如果枚举的质因数的平方大于当前待分解数，待分解数只能是一个质数，可以直接退出。 
2、一个寻址优化。举个例子，你在做dp

我们通过改变存储顺序来优化常数

fo(j,1,m)
    fo(i,1,n)
        f[j][i]=……

3、log函数调用是很慢的，因此可以尝试通过预处理节省时间。 
4、调节块大小能有效卡常！ 
5、多个串并成一个串然后求SA时，为了提高效率可以插入不同的分隔符。 
6、可行性减枝，思考在极端状态下能不能达到要求，不能就直接退出。 
例如：搜索n个数和为s，要求这n个数不降。 
假如搜到了第i个位置，此时第i-1个位置是j，和为k。 
极端情况下，后面所有位置取可行最小值j，那么若k+j*(n-i+1)>s，则搜下去不可能有可行解，可以退出。 
7、记忆化。搜索时注意，对重复状态记忆化来使得总搜索状态不会过多。 
8、一个寻址优化，下面是跑的慢的写法。
f[i+1][next[j][k]]+=f[i][j])%=mo;
考虑寻址优化，下面是跑的快的写法。
t=next[j][k]; (f[i+1][t]+=f[i][j])%=mo;
下列写法通常可以进行优化
(f[i+1][t]+=f[i][j])%=mo;
把+=和%=替换掉
f[i+1][t]=(f[i+1][t]+f[i][j])%mo;
10、别人写的东西。 
转载自Sky_sys 
常数优化和常见问题 
11、启发式合并可能比线段树合并快 
12、分治FFT在区间较小时，可以选择暴力卷积替代FFT。 
13、NTT比FFT更加快速。 
14、你的NTT写法太菜了！我们换一种！注释掉的是原写法。

void DFT(int sig){
    int i;
    fo(i,,len-) tt[rev[i]]=a[i];
    for(register int m=;m<=len;m*=){
        /*int half=m/2,bei=len/m;
        fo(i,0,half-1){
            int wi=sig>0?w[i*bei]:w[len-i*bei];
            for(int j=i;j<len;j+=m){
                int u=tt[j],v=(ll)tt[j+half]*wi%mo;
                tt[j]=(u+v)%mo;
                tt[j+half]=(u-v)%mo;
            }
        }*/
        register int half=m/;
        register int wi=sig>?w[len/m]:w[len-len/m];
        for(i=;i<len;i+=m){
            int o=;
            for(register int j=i;j<i+half;j++,o=(ll)o*wi%mo){
                int v=(ll)o*tt[j+half]%mo;
                tt[j+half]=(tt[j]-v+mo)%mo;
                //tt[j]=(tt[j]+v)%mo;
                tt[j]=tt[j]+v>=mo?tt[j]+v-mo:tt[j]+v;
            }
        }
    }
    if (sig==-)
        fo(i,,len-) tt[i]=(ll)tt[i]*ni%mo;
    fo(i,,len-) a[i]=tt[i];
}

现在的写法让我们的空间访问变的连续，更快了！ 
15、数学函数一般都很慢，如果可以请尽量预处理。 
16、除法比乘法慢很多，如果可以预处理不妨预处理倒数，这样每次就可以用乘法了