整理数学数据结构

#include<bits/stdc++.h>

using namespace std;

const int N = 1e5 + 5;

//树 

struct tree{
	int to[N << 1], nxt[N << 1], hd[N], idx, w[N << 1];
	
	void add(int u, int v, int val) { to[++ idx] = v, nxt[idx] = hd[u], hd[u] = idx, w[idx] = val; }
	
	void dfs(int u, int fa){
		for(int i = hd[u]; i; i = nxt[i]) if(to[i] != fa){
			int v = to[i];
			//...
			dfs(v, u);
			//...
		}
	}
};

//二叉树

struct Binary_tree{
	int tr[N][2];
	
	void pre(int u){
		//objects
		if(tr[u][0]) pre(tr[u][0]);
		if(tr[u][1]) pre(tr[u][1]);
	}
	
	void mid(int u){
		if(tr[u][0]) mid(tr[u][0]);
		//objects
		if(tr[u][1]) mid(tr[u][1]);
	}
	
	void nxt(int u){
		if(tr[u][0]) nxt(tr[u][0]);
		if(tr[u][1]) nxt(tr[u][1]);
		//objects
	}
};

//gcd

int gcd(int a, int b){
	return b == 0 ? a : gcd(b, a % b);
} 

//素数筛

namespace sushushai{
	bitset<1000001> vis;
	int p[1000010], cnt = 0;
	
	void shai(){
		for(int i = 2; i <= 1000000; i ++) {
			if(vis[i]) continue;
			p[++ cnt] = i;
			cerr<<i<<'\n'; 
	//		if(1ll * i * i > 1000000ll) continue;
			for(int j = i * 2; j <= 1000000; j += i) vis[j] = 1;
		}
		for(int i = 1; i <= 25; i ++) cout<<p[i];
	} 
	
}

//排列组合

namespace CA{
	const int Mod = 1e9 + 7;
	
	int n, m, d[1000010], fac[1000010], ifac[1000010], h[1000010], stl[1010][1010], stl1[50010][205];
	
	int qp(int x, int y){ // 快速幂
		x %= Mod;
		int res = 1;
		while(y){
			if(y & 1) (res *= x) %= Mod;
			(x *= x) %= Mod;
			y >>= 1;
		}
		return res;
	}
	
	void init(){ // 阶乘、逆元预处理
		ifac[0] = fac[0] = 1;
		for(int i = 1; i <= 1000; i ++) fac[i] = fac[i - 1] * i % Mod;
		for(int i = 1; i <= 1000; i ++) ifac[i] = qp(fac[i], Mod - 2);
	}
	
	void inith(){ // 卡特兰数
		h[0] = 1;
		for(int i = 1; i <= 1000000; i ++) h[i] = h[i - 1] * (4 * i - 2) % Mod * qp(i + 1, Mod - 2) % Mod;
	}
	
	int C(int x, int y){ // 组合数
		return fac[x] % Mod * ifac[y] % Mod * ifac[x - y] % Mod;
	}
	
	void init2(){ // 错排
		d[0] = 1, d[1] = 0, d[2] = 1;
		for(int i = 3; i <= 1000000; i ++) d[i] = (i - 1) * (d[i - 1] + d[i - 2]) % Mod;
	}
	
	int calt(int x, bool k){ // 卡特兰； 1：预处理；2：现场处理
		if(k) return h[x];
		return (C(2 * x, x) - C(2 * x, x - 1) % Mod + Mod) % Mod;
	}
	
	void initstl(){ // 第二类斯特林数
		stl[0][0] = 1;
		for(int i = 1; i <= 1000; i ++){
			for(int j = 1; j <= i; j ++){
				stl[i][j] = (stl[i - 1][j - 1] + j * stl[i - 1][j] % Mod) % Mod;
			}
		}
	}
	
	void initstl1(){// 第一类斯特林数
		stl1[0][0] = 1;
		for(int i = 1; i <= 50000; i ++){
			for(int j = 1; j <= min(i, 200); j ++){
				stl1[i][j] = (stl1[i - 1][j - 1] + (i - 1) * stl1[i - 1][j] % Mod) % Mod;
			}
		}
	}
} 

//单调

namespace monotonous{
	int n, ans[3000010], q[3000010], a[3000010];
	stack<int> st;
	
	void mstack(){ //单调栈 
		for(int i = 1; i <= n; i ++){
			while(!st.empty() && a[st.top()] < a[i]){
				int id = st.top();
				st.pop();
				ans[id] = i;
			}
			st.push(i);
		} 
	} 
	
	void mqueue(){
		int ll = 1, rr = 0, k = 114514;// k为窗口长度 
		for(int i = 2; i <= n; i ++){
			while(ll <= rr && i - k > q[ll]) ll ++;
			while(ll <= rr && a[q[rr]] > a[i]) rr --;
			q[++ rr] = i;
		}
	}
} 

//DSU

namespace DSU{
	int fa[N], sz[N];
	
	int find(int x){ return x == fa[x] ? x : fa[x] = find(fa[x]); }
	
	void init(){
		for(int i = 1; i <= 10000; i ++) fa[i] = i, sz[i] = 1;
	}
	
	void merge(int u, int v){
		int x = find(u), y = find(v);
		if(x == y) return ;
		sz[y] += sz[x];
		fa[x] = y;
	}
} 

//BIT

namespace BIT{
	int c[N]; 
	
	#define lowbit(x) x&(-x)
	
	void upd(int x, int v){
		for(; x <= N - 5; x += lowbit(x)) c[x] += v;
	}
	
	int qry(int x){
		int res = 0;
		for(; x; x -= lowbit(x)) res += c[x];
		return res;
	}
}

//segtree

namespace segtree{
	int n = 100000, a[N];
	
	#define ls (u << 1)
	#define rs (u << 1 | 1)
	#define mid (l + r >> 1)
	#define segroot int u = 1, int l = 1, int r = n
	#define lson ls, l, mid
	#define rson rs, mid + 1, r
	struct { int sum, add, mul, len; } t[N << 2];
	
	void up(int u) { t[u].sum = t[ls].sum + t[rs].sum; }
	
	void build(segroot){
		t[u].len = r - l + 1;
		if(l == r){ t[u].sum = a[l]; return; }
		build(lson); build(rson); up(u);
	}
	
	void down(int u, int x){ t[u].add += x, t[u].sum += t[u].len * x; }
	
	void down(int u) { down(ls, t[u].add), down(rs, t[u].add), t[u].add = 0; };
	
	int qry(int ql, int qr, segroot){
		if(ql <= l && r <= qr) return t[u].sum;
		down(u);
		if(qr <= mid) return qry(ql, qr, lson);
		if(mid < ql) return qry(ql, qr, rson);
		return qry(ql, qr, lson) + qry(ql, qr, rson);
	}
	
	void mdf(int ql, int qr, int x, segroot) {
		if( qr < l || r < ql ) return;
		if( ql <= l && r <= qr ) return down(u, x);
		down(u), mdf(ql, qr, x, lson), mdf(ql, qr, x, rson), up(u);
	}
}

//分块 

namespace Blocks{
	int n, m, len;
	int w[N], s[N], add[N];
	
	int get_len(int x){
		return x / len;
	}
	
	void mdf(int l, int r, int d){
		if(get_len(l) == get_len(r)) {
			for(int i = l; i <= r; i ++) w[i] += d, s[get_len(i)] += d;
		} else {
			int i = l, j = r;
			while(get_len(i) == get_len(l)) w[i] += d, s[get_len(i)] += d, i ++;
			while(get_len(j) == get_len(r)) w[j] += d, s[get_len(j)] += d, j --;
			for(int k = get_len(i); k <= get_len(j); k ++) s[k] += d * len, add[k] += d;
		}
	}
	
	int qry(int l, int r){
		int res = 0;
		if(get_len(l) == get_len(r)){
			for(int i = l; i <= r; i ++) res += w[i] + add[get_len(i)];
		} else {
			int i = l, j = r;
			while(get_len(i) == get_len(l)) res += w[i] + add[get_len(i)], i ++;
			while(get_len(j) == get_len(r)) res += w[j] + add[get_len(j)], j --;
			for(int k = get_len(i); k <= get_len(j); k ++) res += s[k]; 
		}
		return res;
	}
} 

//树剖

namespace shupou{
	using namespace segtree;
	
	int n = 1e5, a[N], m, rt, p;
	int fa[N], son[N], sz[N], top[N], dep[N], ver[N], dfn[N], ind;

	
	struct Node{
		int to, nxt;
	} ed[N << 1];
	
	int hd[N << 1], cnt;
	
	void addedge(int u, int v){
		ed[++ cnt] = {v, hd[u]};
		hd[u] = cnt;
	}
	
	void dfs1(int u){
		sz[u] = 1;
		for(int i = hd[u]; i; i = ed[i].nxt){
			int v = ed[i].to;
			if(v == fa[u]) continue;
			fa[v] = u;
			dep[v] = dep[u] + 1;
			dfs1(v);
			sz[u] += sz[v];
			if(sz[v] > sz[son[u]]) son[u] = v;
		}
	}
	
	void dfs2(int u, int t){
		top[u] = t, ver[++ ind] = a[u], dfn[u] = ind;
		if(son[u]) dfs2(son[u], t);
		for(int i = hd[u]; i; i = ed[i].nxt){
			int v = ed[i].to;
			if(v == fa[u] || v == son[u]) continue;
			dfs2(v, v);
		}
	}
	
	void add(int u, int v, int x){
		while(top[u] != top[v]){
			if(dep[top[u]] < dep[top[v]]) swap(u, v);
			mdf(dfn[top[u]], dfn[u], x);
			u = fa[top[u]];
		}
		if(dep[u] > dep[v]) swap(u, v);
		mdf(dfn[u], dfn[v], x);
	} 
	
	int sum(int u, int v){
		int res = 0;
		while(top[u] != top[v]){
			if(dep[top[u]] < dep[top[v]]) swap(u, v);
			(res += qry(dfn[top[u]], dfn[u])) %= p;
			u = fa[top[u]];
		}
		if(dep[u] > dep[v]) swap(u, v);
		return (res + qry(dfn[u], dfn[v])) % p;
	} 
} 

int main(){
	return 0;
}