难道我真的是天才？

#### 缺省源

```cpp
#define g(i,j,k) for(int i=j;i<=k;--i)
```

#### 虚树

我不排序。

```cpp
for(int x:p[o])v[a[++s]=x]=1;
a[++s]=b[l=1]=r[t=1]=1;
f(i,1,s){
    c=T.lca(a[i],b[l]);
    if(c!=b[l]){
        for(;T.d[b[l]]>=T.d[c]&&b[l]!=c;--l){
            if(T.lca(b[l],c)==c&&T.d[b[l-1]]<T.d[c])add(c,b[l]);
            else add(b[l-1],b[l]);
        }
        if(b[l]!=c)b[++l]=r[++t]=c;
    }
    if(b[l]!=a[i])b[++l]=r[++t]=a[i];
}
```

我挂两次。

```cpp
f(i,2,l)o[++s]=T.lca(o[i-1],o[i]);
sort(o+1,o+s+1,[&](int x,int y){return T.dfn[x]<T.dfn[y];});
s=unique(o+1,o+s+1)-o-1;
f(i,2,s)add(o[i-1],o[i]);
```

#### 二分

离散化。

```cpp
f(i,1,n){
	s+=abs(a[i]-=(i-1)*d);
	if(a[i]>0)b[++m]=a[i];
}
sort(b+1,b+m+1);T.bt(1,1,m=unique(b+1,b+m+1)-b-1);
f(i,1,n){
	if(a[i]>0){
		l=lower_bound(b+1,b+n+1,a[i])-b;
		T.add(1,1,l-1,-1);
		T.add(1,l,m,1);
	}else{
		T.add(1,1,m,1);
	}
	T.cls(1);
}
```

实数二分。

```cpp
while(le+eps<ri){
	mid=(le+ri)/2;
	ck(mid)?ri=mid:le=mid+1;
}
```

#### 质数

```cpp
inline int prm(int x){for(int i=1;i*i<=x;++i)if(x%i==0)return 0;return 1;}
```

#### 取模

众所周知 C++ 向 $0$ 取整。

```cpp
x=x>=0?x%b:x%b+b;
```

不会运算顺序（$f$ 和 $g$ 是哈希表，没有问题）。

```cpp
int x=f[0][-1]=1;
f(i,1,19){
	x*=10;
	f[i][-1]=x%mo;
	g[i][-1]=x%mo*(x-1)%mo*m2%mo;
}
```

#### 容斥

系数写魔怔了。

```cpp
g(S,m,0)h(T,S)f[S^T]=(f[S^T]+mo+f[S]*(len(T)&1?mo-1:1)%mo)%mo;
```

#### 最短路

floyd 不初始化，不判重边。

#### 并查集

可撤销并查集按秩合并**没合并**，不按秩，不初始化秩。

#### ST 表

中越界。

```cpp
inline void init(int*a,int n){
	f(i,1,n)f[i][0]=a[i];
	f(i,0,k)o[i]=i?o[i-1]*2:1;
	f(i,0,n)p[i]=i?p[i-1]+(o[p[i-1]+1]<=i):0;
	f(t,1,k)f(i,1,n)if(i+o[t]-1<=n)f[i][t]=max(f[i][t-1],f[i+o[t-1]][t-1]);
}
inline int ask(int l,int r){
	int t=o[r-l+1];
	return max(f[l][t],f[r-o[t]+1][t]);
}
```

#### 树状数组

大越界。

```cpp
int c[N][2];
inline void add(int*c,int x,int y){for(int i=x;i<=m;i+=-i&i)c[i]=min(c[i],y);}
```

真数组。

```cpp
inline void add(int x,int y){for(int i=x;i<=n;i+=-i&i)if(f[x]<y)f[x]=y;}
inline int ask(int x,int y=0){for(int i=x;i;i-=-i&i)if(y<f[x])y=f[x];return y;}
```

#### 搜索

如如不动。

```cpp
f(i,1,n)f(j,1,m)f(dx,-1,1)f(dy,-1,1)if(abs(dx)^abs(dy)){
	int x=i+dx,y=i+dy;
}
```

真搜了吗？

```cpp
signed main(){
	cin>>n>>m;
	dfs(1,0,0);
	f(i,1,n)f(j,1,m)a[i][j]=c[i][j]='.';
	printf("%lld\n",s);
	f(i,1,n){
		f(j,1,m)putchar(c[i][j]);
		putchar('\n');
	}
	return 0;
}
```

#### 拓扑

这份代码的初衷是求内向基环树森林除环外的拓扑序，$v[i]>2$ 表示在环上。

```cpp
f(i,1,n)++rd[to[i]];
queue<int>Q;
f(x,1,n){
	if(!rd[x])Q.push(x);
	if(rd[x]&&v[x]>2)Q.push(x),rd[x]=0;
}
for(int x;Q.size();Q.pop()){
	x=to[p[++m]=Q.front()];
	if(rd[x]&&v[x]>2)Q.push(x),rd[x]=0;
	if(rd[x]&&!(--rd[x]))Q.push(x);
} 
```

#### 换根

复杂度为 $\sum {\rm deg}^2$ 的换根（对于每个 $x$ 为根跑一遍 `dfs(x,0,/)`）。

```cpp
void dfs(int x,int fa,int id){
	if(v[id])return;
	int y,z;f[id]=v[id]=1;
	for(xy e:q[x])if(e.x!=fa){
		dfs(y=e.x,x,z=e.y);
		f[id]=max(f[id],f[z]+1);
	}
	if(fa)return;
	z=0;
	for(xy e:q[x])a[++z]=f[e.y];
	sort(a+1,a+z+1);
	f(i,1,z)c[a[i]]=max(c[a[i]],z-i+1);
}
```

记录最长链来源的换根。

```cpp
xy h[N][4],p[4];
inline void ud(xy*a,xy w){
	if(a[0].x<w.x)a[3]=a[2],a[2]=a[1],a[1]=a[0],a[0]=w;
	else if(a[1].x<w.x)a[3]=a[2],a[2]=a[1],a[1]=w;
	else if(a[2].x<w.x)a[3]=a[2],a[2]=w;
	else if(a[3].x<w.x)a[3]=w;
}
void dhs(int x,int fa){
	int y;
	f(t,0,3)h[x][t]=O;
	for(xy e:q[x])if(e.x!=fa){
		dhs(y=e.x,x);
		ud(h[x],(xy){h[y][0].x+a[y],y});
	}
}
```

正在渲染内容...