[一直更新中]错误及好东西

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

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)

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<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，做完后对每个操作打标记表示是否往右区间传即可。
2、两个long long相乘取模怎么办？
第一种是快速乘，类似快速幂，复杂度多了个log
第二种是找一个比较小的数，然后搞一波，详见代码

ll qsc(ll x,ll y){
    ll a1=x/1000000,a2=x%1000000,b1=y/1000000,b2=y%1000000;
    ll t=a1*b1%p*1000000%p*1000000%p;
    t=(t+a2*b2%p);
    t=(t+a1*b2%p*1000000%p);
    t=(t+a2*b1%p*1000000%p);
    return t%p;
}

第三种来自Yves___的博客[long long相乘取模黑科技]
但是他的写法有误，这里做出更正，不知道是否还有错，但已经能过很多题了。
(http://blog.csdn.net/Yves___/article/details/50729044)

ll mul(ll a,ll b,ll p){
    ll tmp=(a*b-(ll)((long double)a/p*b+1e-8)*p);
    return tmp<0?tmp+p:(tmp>=mo?tmp-mo:tmp);
}

大概意思就是强制转double然后搞一波再转回来。
3、unique()可以删除重复元素，然后返回删除重复元素后的末端地址。
下面这段代码即可实现离散化。

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

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

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

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

5、调用头文件bits/stdc++.h就相当于包括了好多库……
6、如何打伪随机数？

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

7、对拍（从前一直用c++对拍的蒟蒻就是我）

在程序的目录下建立.txt文件，输入：

@echo off
:loop
data.exe //生成数据
right.exe //要对拍的
brute_force.exe //暴力
fc data1.out data2.out //两个程序的输出文件
if not errorlevel 1 goto loop
pause
goto loop

把文件扩展名名改成.bat

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[i][j]=……

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

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;

9、下列写法通常可以进行优化

(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,0,len-1) tt[rev[i]]=a[i];
    for(register int m=2;m<=len;m*=2){
        /*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/2;
        register int wi=sig>0?w[len/m]:w[len-len/m];
        for(i=0;i<len;i+=m){
            int o=1;
            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==-1)
        fo(i,0,len-1) tt[i]=(ll)tt[i]*ni%mo;
    fo(i,0,len-1) a[i]=tt[i];
}

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