乱七八糟的模板集合

字符串

1.字符串哈希

可以用于直接比较字符串相同，找循环节,hash(l, r - x) == hash(l + x, r) 可判定x为一个循环节（x整除长度）

// 采用自然溢出
typedef unsigned long long ull;
const short base = 131;
ull hashs[maxn],bases[maxn];
void init() {
    bases[0] = 1;
    for(int i = 1; i <= n; ++i) {
        bases[i] = bases[i - 1] * base;
        hashs[i] = hashs[i - 1] * base + str[i] - 'a' + 1;
    }
}
ull get_hash(int l, int r) {
    return hashs[r] - hashs[l - 1] * bases[r - l + 1];
}

2.KMP

 单模式串匹配，着重理解前缀数组的应用,比如n - next[n]为最小循环节

for(int i = 2, j = 0; i <= len2; i++) {
    while(j && s2[i] != s2[j + 1]) j = next[j];
    if(s2[i] == s2[j + 1]) j++;
    next[i] = j; 
}
for(int i = 1, j = 0; i <= len1; i++) {// 单模式串匹配
    while(j && s1[i] != s2[j + 1]) j = next[j];
    if(s1[i] == s2[j + 1]) j++;
    if(j == len2) {// 匹配成功
        printf("%d\n", i - len2 + 1);
    }
} 

3.AC自动机

多模式串匹配，一般多串跑不了

struct AC_automation {
    int ch[maxn][26],tot,fail[maxn],ending[maxn];
    //子节点，结点数，失配指针，结束标记
    void insert(char *str, int len) {// trie插入 
        int p = 0;
        char c;
        for(int i = 0; i < len; ++i) {
            c = str[i] - 'a';
            if(!ch[p][c]) ch[p][c] = ++tot;
            p = ch[p][c];
        }
        ending[p]++;
    } 
    void build() {// 构建失配指针
        int head = 1, tail = 0, q[maxn], p;
        for(int i = 0; i < 26; ++i){
            if(!ch[0][i]) continue;
            q[++tail] = ch[0][i];
            fail[ch[0][i]] = 0;
        }
        while(head <= tail) {
            p = q[head++];
            for(int i = 0; i < 26; ++i) {
                if(ch[p][i]){
                    fail[ch[p][i]] = ch[fail[p]][i];//error#1
                    q[++tail] = ch[p][i];
                }
                else ch[p][i] = ch[fail[p]][i];// error#2
            }
        }
    }
    void match(char *str, int len) {// 匹配文本
        int p = 0, ret = 0;
        for(int i = 0; i < len; ++i) {
            p = ch[p][str[i] - 'a'];
            for(int j = p; j; j = fail[j]) {
                // 根据题目要求自行变通
            }
        } 
    }
}AC;

4.trie

（不要问我为什么trie在ACAM后面，问就是忘加了。。）下面代码以查询一个串是几个串的前缀为例

struct trie {
    int ch[maxn][63],tot,val[maxn];// 可以用val标记这个点有多少个单词经过
    void insert(char *str, int len) {
        int p = 0;
        for(int i = 1; i <= len; ++i) {
            int c = trans(str[i]);
            if(!ch[p][c]) ch[p][c] = ++tot;
            p = ch[p][c];
            ++val[p];
        }
    }
    int match(char *str, int len) {
        int p = 0;
        for(int i = 1; i <= len; ++i) {
            p = ch[p][trans(str[i])];
            if(!p) return 0;
        }
        return val[p];
    }
    void clear() {// 别用memset要T飞的
        for(int i = 0; i <= tot; ++i)
            for(int j = 0; j <= 62; ++j)
                ch[i][j] = 0;
        for(int i = 0; i <= tot; ++i)
            val[i] = 0;
        tot = 0;
    }
}t;

5.后缀数组

倍增后缀数组，整了一长串注释方便自己理解

int n,m,sa[maxn],rk[maxn],tp[maxn],tax[maxn];
// 通俗易懂(当前长度len):
// sa[i]:上次排序排i的后缀哪个
// rk[i]:上次排序第i个后缀排第几 rk[sa[i]] = i
// tp[i]:辅助排序 第二关键字 跟sa[i]描述的差不多 不过是后半段 
// tax[i]:基数排序的桶
// m:字符集大小
void radix_sort() {
    for(int i = 1; i <= m; ++i) tax[i] = 0;// 清空
    for(int i = 1; i <= n; ++i) ++tax[rk[i]];// 存 
    for(int i = 1; i <= m; ++i) tax[i] += tax[i - 1];// 做前缀和可以得到比i小的后缀有多少
    for(int i = n; i >= 1; --i) sa[tax[rk[tp[i]]]--] = tp[i];
    // 最阴间的一句话
    // 我们考虑len -> 2*len会如何变化
    // 第一关键字相对位置不变 rk即排名相同的后缀会变化
    // 这个时候我们通过tp把这些后缀区分开 tp保证两两不同
    // 由于tax存的第一关键字桶 而且做前缀和之后是这个段最大的排名
    // 我们倒序枚举i rk[tp[i]]定位到第一关键字 这个时候桶的值就是真的排名
} 
void suffix_sort() {
    for(int i = 1; i <= n; ++i) rk[i] = str[i], tp[i] = i, m = max(m, (int)str[i]);
    // 一开始莫得第二关键字就拿自己位置了
    radix_sort();// 先排一次
    for(int p, len = 1; p < n; len <<= 1, m = p) {// p就是个排名计数器
        p = 0;
        for(int i = 1; i <= len; ++i) tp[++p] = n - len + i;// 这些没有第二关键字 当0了 
        for(int i = 1; i <= n; ++i) 
            if(sa[i] > len) tp[++p] = sa[i] - len;// 这些有第二关键字 丢进去
        radix_sort(); swap(tp, rk); rk[sa[1]] = p = 1; 
        // 排序 然后tp由于没用 我们就相当于拿tp来存rk的拷贝来更新新的rk  
        for(int i = 2; i <= n; ++i)
            rk[sa[i]] = (tp[sa[i]] == tp[sa[i - 1]] && tp[sa[i] + len] == tp[sa[i - 1] + len]) ? p : ++p;
        // 两个关键字都相同的排名相同 
    } 
        for(int i = 1, k = 0; i <= n; ++i) {// 获取height数组
        if(!rk[i]) continue;
        if(k) --k;
        while(str[i + k] == str[sa[rk[i] - 1] + k]) ++k;
        height[rk[i]] = k;
    }
} 

6.后缀自动机

虽然但是这玩意应该不考吧，以防万一

struct Suffix_AutoMaton {
    int link[maxn],len[maxn],tot,last;
    map<char, int>ch[maxn];
    Suffix_AutoMaton() {
        tot = last = 1;
        link[1] = len[1] = 0;
        ch[1].clear();
    }
    void insert(char c) {
        int cur = ++tot, p = last; sz[cur] = 1;
        len[cur] = len[last] + 1;
        while(p && ch[p].find(c) == ch[p].end()) {
            ch[p][c] = cur;
            p = link[p];
        }
        if(!p) link[cur] = 1;
        else {
            int q = ch[p][c];
            if(len[p] + 1 == len[q]) link[cur] = q;
            else {
                int cl = ++tot;
                ch[cl] = ch[q];
                link[cl] = link[q];
                len[cl] = len[p] + 1;
                while(p && ch[p][c] == q) {
                    ch[p][c] = cl;
                    p = link[p];
                }
                link[q] = link[cur] = cl;
            }
        }
        last = cur;
    }
}SAM;

数据结构

1.并查集

短小且精悍，灵活运用

int fa[maxn];
void init() {// 初始化 一定要记得
    for(int i = 1; i <= n; ++i) fa[i] = i;
}
int getfa(int x) {// 查询所属于集合 路径压缩优化
    return fa[x] == x ? x : fa[x] = getfa(fa[x]);  
}
void merge(int x, int y) {// 合并
    x = getfa(x), y = getfa(y);
    fa[x] = y;
}
bool same(int x, int y) {// 查询是否在同一集合
    return getfa(x) == getfa(y);
}

2.树状数组

一样短小精悍，高效维护动态前缀和

#define lowbit(x) ((x) & (-x))
int t[maxn];
void add(int x, int a) {
    while(x <= n) {
        t[x] += a;
        x += lowbit(x);
    }
}
int sum(int l, int r) {
    --l;
    int suml = 0, sumr = 0;
    while(l) {
        suml += t[l];
        l -= lowbit(l);
    }
    while(r) {
        sumr += t[r];
        r -= lowbit(r);
    }
    return sumr - suml;
}

求逆序对

其还有各种变体，例如求逆序对(看见什么冒泡排序，就可以想想逆序对)

struct num {
    int v,id;
    friend bool operator < (const num &n1, const num &n2) {
    // 处理重复情况
        if(n1.v == n2.v) return n1.id < n2.id;
        return n1.v < n2.v;
    }
}a[maxn];// a[i].v为真实值
int main() {
    //输入
    sort(a + 1, a + n + 1);
    for(int i = 1; i <= n; ++i) b[a[i].id] = i;// 离散化
    for(int i = 1; i <= n; ++i) {
        add(b[i]);
        ans += i - sum(b[i]);
    }
    return 0;
}

值域树状数组

 离线的弱化平衡树(?)

int sum(int x) {
    int ret = 0;
    while(x){
        ret += t[x];
        x -= lowbit(x);
    }
    return ret;
}
void add(int x, int v) {
    if(!(sum(x) - sum(x - 1)) && v < 0) return;// 虚空减法
    while(x <= n){
        t[x] += v;
        x += lowbit(x); 
    }
}
int rnk(int x) {// 查询x排名 
    return sum(x - 1) + 1;
}
int kth(int x) {// 倍增查询第k小数 编号
    int ret = 0,cnt = 0;
    for(int i = lg; ~i; i--) {// lg为log2n
        ret += 1 << i;
        if(ret > n || cnt + t[ret] >= x) ret -= 1 << i;
        else cnt += t[ret];
    }
    return ret + 1;
}
int id(int x) {
    return lower_bound(b + 1,b + lim + 1, x) - b;
}
int pre(int x) {// x前驱编号
    return kth(rnk(x) - 1);
}
int next(int x) {// x后继编号
    return kth(rnk(x + 1));
}
/*
假设a为原数组(除了kth操作存下来的数)，b为排序去重后数组
插入add(id(a[i]), 1);
删除add(id(a[i]), -1);
排名rnk(id(a[i]));
第k大b[kth(a[i])];
前驱b[pre(id(a[i]))]
后继b[next(id(a[i]))]
*/

3.线段树

 维护区间等，还有各种变体

struct segment_tree {
    int l,r;
    long long tag;
    long long sum;
}t[maxn << 2];// 注意开4倍空间
void pushup(int p) {
    t[p].sum = t[p << 1].sum + t[p << 1 | 1].sum;
}
void pushdown(int p) {// 有取模的要注意取模问题
    if(t[p].tag) {
        t[p << 1].tag += t[p].tag;
        t[p << 1 | 1].tag += t[p].tag;
        t[p << 1].sum += t[p].tag * (t[p << 1].r - t[p << 1].l + 1);
        t[p << 1 | 1].sum += t[p].tag * (t[p << 1 | 1].r - t[p << 1 | 1].l + 1);
        t[p].tag = 0;
    }
}
void build(int p, int l, int r) {// 调用build(1, 1, n)
    t[p].l = l; t[p]. r = r;
    if(l == r) {
        t[p].sum = a[l];
        return;
    }
    int mid = l + r >> 1;
    build(p << 1, l, mid);
    build(p << 1 | 1, mid + 1, r);
    pushup(p);
}
void change(int p, int l, int r, long long k) {// k要开long long
    if(t[p].l >= l && t[p].r <= r) {
        t[p].tag += k;
        t[p].sum += k * (t[p].r - t[p].l + 1);
        return;
    }
    pushdown(p);
    int mid = t[p].l + t[p].r >> 1;
    if(l <= mid) change(p << 1, l, r, k);// 注意这里不要把l,r改了
    if(r > mid) change(p << 1 | 1, l, r, k);
    pushup(p);
}
long long ask(int p, int l, int r) {
    if(t[p].l >= l && t[p].r <= r) return t[p].sum;
    pushdown(p);
    int mid = t[p].l + t[p].r >> 1;
    long long ret = 0;
    if(l <= mid) ret += ask(p << 1, l, r, k);// 注意这里不要把l,r改了
    if(r > mid) ret += ask(p << 1 | 1, l, r, k);
    return ret;// 有取模就要注意
}

可持久化权值线段树（主席树）

 查询区间第k小

int build(int p, int l, int r) {// 版本0建树
    if(!p) p = ++tot;
    if(l == r) return p;
    int mid = (l + r) >> 1;
    ls[p] = build(ls[p], l, mid);
    rs[p] = build(rs[p], mid + 1, r);
    return p;
}
int copy_node(int p) {
    ls[++tot] = ls[p];
    rs[tot] = rs[p];
    sum[tot] = sum[p] + 1;
    return tot;
}
int change(int p, int l, int r, int pos) { //插入操作
    p = copy_node(p);
    if(l == r) return p;
    int mid = l + r >> 1;
    if(pos <= mid) ls[p] = change(ls[p], l, mid, pos);
    else rs[p] = change(rs[p], mid + 1, r, pos);
    return p;
}
int query(int ql, int qr, int l, int r, int k) {
    // 通过区间减法去掉序列1~ql范围存储的左子树区间的权值
    int x = sum[ls[qr]] - sum[ls[ql]]; 
    if(l == r) return l; 
    int mid = (l + r) >> 1;
    if(k <= x) return query(ls[ql], ls[qr], l, mid, k);
    return query(rs[ql], rs[qr], mid + 1, r, k - x);
}
// 插入要一个一个插入 离散化后 rt[i] = change(rt[i - 1], 1, len, lsh[a[i]]) lsh为离散化 len为值域上限
// 查询调用 id[query(rt[l - 1], rt[r], 1, len, k)];

可持久化线段树

 可持久化数组，可以搞可持久化并查集之类的东西（本质是fa数组可持久化）

int num[maxn];// 初始值 
struct persistence_segment_tree {
    int ls[limit],rs[limit],val[limit],rt[maxn],tot,nrt;
    int build(int l, int r) {
        int p = ++tot;
        if(l == r) {
            val[p] = num[l];
            return p;
        }
        int mid = l + r >> 1;
        ls[p] = build(l, mid);
        rs[p] = build(mid + 1, r);
        return p;
    }
    int copy_node(int p) {
        ls[++tot] = ls[p];
        rs[tot] = rs[p];
        return tot;
    }
    int change(int p, int l, int r, int pos, int k) {
        p = copy_node(p);
        if(l == r) {
            val[p] = k;
            return;
        }
        int mid = l + r >> 1;
        if(l <= mid) ls[p] = change(ls[p], l, mid, pos, k);
        else rs[p] = change(rs[p], mid + 1, r, pos, k);
        return p;
    }
    int query(int p, int l, int r, int pos) {
        if(l == r) return val[p];
        int mid = l + r >> 1;
        if(pos <= mid) return query(ls[p], l, mid, pos);
        else return query(rs[p], mid + 1, r, pos);
    }
}; 
/*
这是可持久化线段树，非权值 
建树：先把num初始化完，调用t.rt[0] = t.build(1, n);
每次操作(存版本)开始就t.rt[i] = t.rt[i - 1];
更改版本 t.rt[i] = t.rt[version]; 
更改数 t.rt[i] = t.change(t.rt[i], 1, n, pos, k) 真实数组t[pos] = k;
其中t.rt[i] 也可改为基于的版本
查询数t.query(t.rt[i], 1, n, pos); 查询真实数组在版本i的t[pos]值; 
*/

线段树合并

 统计子树大小就dfs一遍从子树合并上来即可(先递归再合并)

int merge_segment_tree(int p, int q, int l, int r) {
    if(!p) return q;
    if(!q) return p;// 一个空了返回另一个
    if(l == r) {
        // 根据题目要求修改
        return p;
    }
    int mid = (l + r) >> 1;
    ls[p] = merge_segment_tree(ls[p], ls[q], l, mid);// 权值线段树
    rs[p] = merge_segment_tree(rs[p], rs[q], mid + 1, r);
    pushup(p);
    return p; 
}

4.树链剖分

用于树上修改、查询等问题，核心思想为给树上每个结点重新编号存到线段树里面，使得根节点到每个点经过链条数均摊logn，虽然(logn)^2但是常数小，除非完全二叉树，不然叠不满，还可以拿来求LCA（CSP-S2022 树剖LCA打挂 警钟长鸣）编号过程通过两次dfs实现，修改就是两个结点一起跳重链，直到到LCA，在线段树里一段一段地修改就可以了

int son[maxn],size[maxn],fa[maxn],dep[maxn],rev[maxn],seg[maxn].top[maxn];
// 重儿子编号，子树大小，父节点，深度，线段树中结点在原树中编号，原树中结点在线段树中编号，某个点所在重链链顶结点编号
void dfs1(int p, int last) {
    dep[p] = dep[last] +1;
    fa[p] = last;
    size[p] = 1;
    for(int i  = head[p]; i; i = e[i].next) {// 邻接表
        if(e[i].to == last) continue;
        dfs1(e[i].to, p);
        size[p] += size[e[i].to];
        if(size[e[i].to] > size[son[p]]) {
            son[p] = e[i].to;
        }
    }
}
// seg[0]存当前编号数，如果有从零开始编号的出题人你。。。
void dfs2(int p) {// 主函数用 seg[0] = seg[root] = 1; top[root] = rev[root] = root; root为1时直接拉到底
    if(son[p]) {
        top[son[p]] = top[p];
        seg[son[p]] = ++seg[0];
        rev[seg[0]] = son[p];// 线段树建树调用的rev
        dfs2(son[p]);
    }
    for(int i = head[p]; i; i = e[i].next) {
        if(top[e[i].to]) continue;
        top[e[i].to] = e[i].to;
        seg[e[i].to] = ++seg[0];
        rev[seg[0]] = e[i].to;
        dfs2(e[i].to);
    }
}

树剖求LCA

 同修改过程，一段一段跳，然后两个结点在一条重链上的时候，深度较小的那个点就是LCA了，比又慢又难写的倍增好多了

int lca(int x, int y) {
    while(top[x] != top[y]) {
        if(dep[top[x]] < dep[top[y]]) swap(x, y);// 深度大的链向上跳，注意是链顶深度，考场写挂。。
        x = fa[top[x]];
    }
    return dep[x] < dep[y] ? x : y;// 深度小的就是LCA了，同一条链上了
}

修改/查询大同小异，就是在每次跳链之前调用change/ask(1, seg[top[x]], seg[x], ......)(链顶编号较小)，最后同一条链上时再调用一次就行了

5.ST表

ST表用于解决静态RMQ问题，基于倍增思想，O(nlogn)预处理，O(1)查询，就是细节有点多（CSP-S2022 T2 ST表忘初始化 60 -> 15 警钟长鸣）

// 下回最好写函数版不然太乱
int st[log2(maxn)][maxn],lg2[maxn],a[maxn];// lg2要预处理才能做到高效，a原数组，st[i][j]表示第j个数后面2^i个数（包括本身）中的最大最小数
void init() {
    lg2[0] = -1;
    for(int i = 1; i <= n; ++i)// 记得初始化
        lg2[i] = lg2[i >> 1] + 1;
        st[0][i] = a[i];
    }
    for(int i = 1; i <= lg2[n]; ++i)// 注意细节
        for(int j = 1; j <= n - (1 << i) + 1; ++j) {
            st[i][j] = max(st[i  - 1][j], st[i - 1][j + (1 << (i - 1))];// 可根据实际更改
        }
}
int query(int l, int r) {
    int temp = lg2[r - l + 1];
    return max(st[temp][l], st[temp][r - (1 << temp) + 1]);// 要+1
}

 6.单调队列/单调栈

可以用来优化dp等但是我要是能设计出来状态就磕头了,也可以变个形变成单调栈，既然有单调性也可以考虑二分等

struct dandiao_queue {// 以保留较大值为例 
    int q[maxn],head,tail;
    dandiao_queue() {
        head = 1;
        tail = 0;
    }
    int front() {
        if(head > tail) return 998244353;// 自行改错误代码 有用
        return q[head];
    }
    void pop() {
        if(head > tail) return;
        ++head;
    }
    void push(int x) {
        while(tail >= head && x > q[tail]) --tail;// 记得要判队列非空 自行调整比较方式 
        q[++tail] = x;
    }
    void bl() {// debug 用 
        printf("now queue:");
        for(int i = head; i <= tail; ++i) printf("%d ", q[i]);
        printf("\n");
    }
}q;

 7.分块

核心思想是大段整体维护，局部暴力，大多数题目需要离散化等几步转化，贴个简单板子。利用基本不等式得出块长为$\sqrt{n}$时最优，大多数时候时间复杂度为$O(n\sqrt{n})$，大概可以卡常过1e5

int n,a[maxn],tot,sq,id[maxn];// sq块长 tot块数
struct kuai {
    int l,r,add;// add区间加标记 
}blo[sqrt(maxn)];
void add(int l, int r, int z) {
    int x = id[l], y = id[r];
    if(x == y) {
        for(int i = l; i <= r; ++i) a[i] += z;
        return;
    }
    for(int i = l; i <= blo[x].r; ++i) a[i] += z;
    for(int i = x + 1; i <= y - 1; ++i) blo[i].add += z;
    for(int i = blo[y].l; i <= r; ++i) a[i] += z;
}
int query(int x) {
    return blo[id[x]].add + a[x];
}
int main() {
    sq = sqrt(n);
    for(int i = 1; 1; ++i) {
        if(i * sq > n) {
            tot = i - 1;
            break;
        }
        blo[i].l = blo[i - 1].r + 1;
        blo[i].r = blo[i].l + sq - 1;
    }
    if(blo[tot].r < n) {
        ++tot;
        blo[tot].l = blo[tot - 1].r + 1;
        blo[tot].r = n;
    }
    for(int i = 1; i <= tot; ++i) 
        for(int j = blo[i].l; j <= blo[i].r; ++j) 
            id[j] = i;
        return 0;
}

 8.莫队

其实准确来说莫队算是一种技巧(?)吧，但是跟分块思想有点像我就放一起了，莫队基于给询问按一定方式排序，然后将已知答案区间一个一个移动就行

看见可离线，区间询问，就可以想到莫队。大多数莫队题目还是要转化一下，由于修改很多，通常配合值域分块，来进行$O(1)$修改$O(\sqrt{n})$查询

背框架主要是背个奇偶化排序，另外注意莫队询问区间先扩张后收缩

struct query{// 存询问的 
    int l,r,id;
    friend bool operator < (const query &q1,const query &q2) {
        if(q1.l / sq != q2.l / sq) return q1.l < q2.l;
        else {
            if(q1.l / sq & 1) return q1.r < q2.r;
            return q1.r > q2.r;
        }
    }
}ask[maxn];// sq为询问块长自行定
sort(ask + 1, ask + q + 1);
for(int l = 1,r = 0,i = 1; i <= q; i++) {
    while(l < ask[i].l)del(l++);// del、add就是删/增统计，自行更改
    while(l > ask[i].l)add(--l);
    while(r < ask[i].r)add(++r);
    while(r > ask[i].r)del(r--);
    ans[ask[i].id] = ;// 统计答案
}

9.平衡树(fhq-treap)

fhq_treap好写好用

mt19937 rnd(time(0));
struct fhq_treap {
    int size[maxn],ls[maxn],rs[maxn],val[maxn],tot,wei[maxn],root;
    int New(int v) {
        size[++tot] = 1;
        val[tot] = v;
        wei[tot] = rnd();
        return tot;
    }
    void pushup(int p) {size[p] = size[ls[p]] + size[rs[p]] + 1;}
    void Split(int p, int v, int &x, int &y) {
        if(!p) {x = 0; y = 0; return;}
        if(val[p] <= v){x = p; Split(rs[p], v, rs[p], y);}
        else {y = p; Split(ls[p], v, x, ls[p]);}
        pushup(p);
    }
    int Merge(int x, int y) {
        if((!x) || (!y)) return x + y;
        if(wei[x] < wei[y]) {
            rs[x] = Merge(rs[x], y);
            pushup(x);
            return x;
        }
        else {
            ls[y] = Merge(x, ls[y]);
            pushup(y);
            return y;
        }
    }
    void insert(int v) {
        int x,y;
        Split(root, v, x, y);
        root = Merge(Merge(x, New(v)), y);
    }
    void del(int v) {
        int x,y,z;
        Split(root, v, x, z);
        Split(x, v - 1, x, y);
        root = Merge(Merge(x, Merge(ls[y], rs[y])), z);
    }
    int find(int p, int kth) {
        if(size[ls[p]] + 1 == kth) return p;
        if(kth < size[ls[p]] + 1) return find(ls[p], kth);// 又写反了。。 
        return find(rs[p], kth - size[ls[p]] - 1);
    }
    int rnk(int v) {
        int x,y,ret;
        Split(root, v - 1, x, y);
        ret = size[x] + 1;
        root = Merge(x, y);
        return ret;
    }
    int pre(int v) {
        int x,y,ret;
        Split(root, v - 1, x, y);
        ret = val[find(x, size[x])];
        root = Merge(x, y);
        return ret;
    }
    int nxt(int v) {
        int x,y,ret;
        Split(root, v, x, y);
        ret = val[find(y, 1)];
        root = Merge(x, y);
        return ret;
    }
}t;

 10.Link-Cut-Tree

LCT反正不考，但是万一有更优解可以用，留一个板子在这

struct mypair {
    int x,y;
    friend bool operator < (const mypair &m1, const mypair &m2) {
        return m1.x < m2.x;
    }
};
struct link_cut_tree {
    mypair mx[maxn << 2],val[maxn << 2];
    int fa[maxn << 2],ch[maxn << 2][2];
    bool rev[maxn << 2];
    #define isroot(p) ((ch[fa[p]][0] != p) && (ch[fa[p]][1] != p))
    #define get(p) (ch[fa[p]][1] == p)
    #define ls ch[x][0]
    #define rs ch[x][1]
    void pushup(int x) {mx[x] = max(val[x], max(mx[ls], mx[rs]));}
    void rever(int x) {swap(ls, rs); rev[x] ^= 1;}
    void pushdown(int x) {
        if(rev[x]) {
            if(ls) rever(ls);
            if(rs) rever(rs);
            rev[x] = 0;
        }
    }
    void update(int x) {
        if(!isroot(x)) update(fa[x]);
        pushdown(x);
    }
    void rotate(int x) {
        int y = fa[x], z = fa[y], k = get(x);
        if(!isroot(y)) ch[z][get(y)] = x;
        ch[y][k] = ch[x][!k], fa[ch[x][!k]] = y;
        ch[x][!k] = y; fa[y] = x; fa[x] = z;
        pushup(x); pushup(y);
    }
    void splay(int x) {
        update(x);
        for(int y = fa[x]; !isroot(x); rotate(x), y = fa[x])
            if(!isroot(y)) rotate(get(y) == get(x) ? y : x);
    }
    void access(int x) {
        for(int y = 0; x; y = x, x = fa[x]) {
            splay(x);
            ch[x][1] = y;
            pushup(x);
        }
    }
    void makeroot(int x) {
        access(x);
        splay(x);
        rever(x);
    }
    int findroot(int x) {// 找根 连通性
        access(x);
        splay(x);
        pushdown(x);
        while(ch[x][0]) {// 找深度最浅的那个 
            x = ch[x][0];
            pushdown(x);
        }
        splay(x);// 旋上去保证复杂度
        return x; 
    }
    void split(int x, int y) {
        makeroot(x);
        access(y);
        splay(y);
    }
    void link(int x, int y) {
        makeroot(x);
        fa[x] = y;
    }
    void cut(int x, int y) {
        makeroot(x);
        access(y);
        splay(y);// 上面三行可以直接换成split(x, y)
        fa[x] = ch[y][0] = 0;
        pushup(y);
    }
}LCT;

 11.树套树

写法是权值线段树套平衡树，空间复杂度$O((n+m)\log{V})$，时间复杂度$O((n+m)\log{n}\log{V})$

但是这玩意是真难写啊

struct fhq_treap {
    int tot,ls[maxn],rs[maxn],wei[maxn],sz[maxn],ps[maxn];
    int New(int v) {
        ps[++tot] = v;
        wei[tot] = rnd();
        sz[tot] = 1;
        return tot;
    } 
    void pushup(int p) {sz[p] = sz[ls[p]] + sz[rs[p]] + 1;}
    void split(int p, int v, int &x, int &y) {// 偶尔压行一下 
        if(!p) {x = y = 0; return;}
        if(ps[p] <= v) {x = p; split(rs[p], v, rs[p], y);}
        else {y = p; split(ls[p], v, x, ls[p]); }
        pushup(p);
    }
    int Merge(int x, int y) {
        if(!x || !y) return x + y;
        if(wei[x] < wei[y]) {
            rs[x] = Merge(rs[x], y);
            pushup(x);
            return x;
        }
        else {
            ls[y] = Merge(x, ls[y]);
            pushup(y);
            return y;
        }
    }
    void insert(int &p, int v) {
        int x, y;
        split(p, v, x, y);
        p = Merge(x, Merge(New(v), y));
    }
    void del(int &p, int v) {
        int x, y, z;
        split(p, v, x, z);
        split(x, v - 1, x, y);
        p = Merge(x, z);
    }
    int getsum(int &p, int l, int r) {
        int x, y, z, res = 0;
        split(p, l - 1, x, y);
        split(y, r, y, z);
        res = sz[y];
        p = Merge(x, Merge(y, z));
        return res;
    }
    void bl(int p) {
        if(ls[p]) bl(ls[p]);
        cout << ps[p] << ' ';
        if(rs[p]) bl(rs[p]);
    }
}T1;
struct segment_tree {
    int tot = 1,ls[maxn],rs[maxn],id[maxn];
    int getrnk(int p, int l, int r, int ql1, int qr1, int ql2, int qr2) {
        // ql1,qr1是外层区间(值域) ql2 qr2是内层区间(位置)
        if(!p || ql1 > qr1) return 0;
        if(l >= ql1 && r <= qr1) return T1.getsum(id[p], ql2, qr2);
        int mid = (l + r) >> 1, res = 0;
        if(ql1 <= mid) res = getrnk(ls[p], l, mid, ql1, qr1, ql2, qr2);
        if(qr1 > mid) res += getrnk(rs[p], mid + 1, r, ql1, qr1, ql2, qr2);
        return res;
    }
    int kth(int p, int l, int r, int ql2, int qr2, int k) {
        if(l == r) return l;
        int tp = T1.getsum(id[ls[p]], ql2, qr2);
        int mid = (l + r) >> 1;
        if(tp >= k) return kth(ls[p], l, mid, ql2, qr2, k);
        return kth(rs[p], mid + 1, r, ql2, qr2, k - tp);
    }
    int insert(int p, int l, int r, int pos, int k) {
        if(!p) p = ++tot;
        T1.insert(id[p], pos);
        if(l == r) return p;
        int mid = (l + r) >> 1;
        if(k <= mid) ls[p] = insert(ls[p], l, mid, pos, k);
        else rs[p] = insert(rs[p], mid + 1, r, pos, k);
        return p;
    }
    void del(int p, int l, int r, int pos, int k) {
        T1.del(id[p], pos);
        if(l == r) return;
        int mid = (l + r) >> 1;
        if(k <= mid) del(ls[p], l, mid, pos, k);
        else del(rs[p], mid + 1, r, pos, k);
    }
    int pre(int l, int r, int k) {
        int rk = getrnk(1, 0, V, 0, k - 1, l, r) + 1;
        if(rk == 1) return -inf;
        return kth(1, 0, V, l, r, rk - 1);
    }
    int nxt(int l, int r, int k) {
        int rk = getrnk(1, 0, V, 0, k, l, r) + 1;
        if(rk > r - l + 1) return inf;
        return kth(1, 0, V, l, r, rk);
    }
}T2;

 

图论

1.最短路

dijkstra

时间复杂度$O(nlogn)$，目前最快的单源最短路径算法，没有负边权时可用

struct node {
    int id,dis;
    friend bool operator > (const node &n1, const node &n2) {
        return n1.dis > n2.dis;
    }
};
priority_queue<node, vector<node>, greater<node> >q;
void dijkstra() {
    memset(dis, 0x3f, sizeof(dis));
    dis[s] = 0;
    q.push((node) {s, 0});
    while(q.size()) {
        int p = q.top().id; q.pop();
        if(vis[p]) continue;
        vis[p] = 1;
        for(int i = head[p]; i; i = e[i].next) {
            int v1 = e[i].to, w1 = e[i].w;
            if(dis[v1] > dis[p] + w1) {
                dis[v1] = dis[p] + w1;
                q.push((node) {v1, dis[v1]});
            }
        }
    }
}

SPFA(队列优化的bellman-ford算法)

虽然SPFA已死，但是其在判定负环、处理负权边、费用流等方面有着不可替代的地位

下面代码以SPFA判定负环同时求最短路为例给出代码

bool SPFA() {// 返回true就是无负环 也可用于差分约束
    dist[n + 1] = 0;
    cnt[n + 1] = 1;
    inq[n + 1] = 1;
    for(int i = 1; i <= n; ++i) dist[i] = 0x3f3f3f3f;
    q.push(n + 1);
    while(q.size()) {
        int p = q.front(); q.pop();
        inq[p] = 0;
        for(int i = head[p]; i; i = e[i].next) {
            int v1 = e[i].to, w1 = e[i].w;
            if(dist[v1] > dist[p] + w1) {
                dist[v1] = dist[p] + w1;
                if(!inq[v1]) {
                    if(++cnt[v1] > n) return false;
                    q.push(v1);
                    inq[v1] = 1;
                }
            }
        }
    }
    return true;
}

floyd

floyd用于求全源最短路，本质是动态规划，所以阶段中转点k作为动态规划的阶段需要放在最外层

且由于min、+运算满足结合律，floyd也可用于重定义矩阵乘法，算出经过n条路径的最短路径长度

// 记得初始化dist为inf
for(int k = 1; k <= n; ++k)
    for(int i = 1; i <= n; ++i)
        for(int j = 1; j <= n; ++j)
            dist[i][j] = min(dist[i][k] + dist[k][j], dist[i][k];

2.LCA

树链剖分求LCA，详见树链剖分部分

3.tarjan系列

tarjan系列都离不开时间戳（dfn）和追溯值（low）两个数组的更新，tarjan时都在主函数中把没有遍历过的节点再dfs一遍(!dfn[i])

强连通分量

多用于有向图的缩点，缩点之后可以变成一个DAG，进行dp等操作。强联通分量判定法则：dfs回溯时，若dfn[x] == low[x]，则x及其当前搜索子树处于同一个强连通分量内，为了存下搜索树中所有节点，我们使用一个栈来模拟，每次dfs都存下当前节点

void tarjan(int p) {
    st[++top] = p; ins[p] = 1;
    dfn[p] = low[p] = ++num;
    for(int i = head[p]; i; i = e[i].next) {
        if(!dfn[e[i].to]) {
            tarjan(e[i].to);
            low[p] = min(low[p], low[e[i].to]);
        }
        else if(ins[e[i].to]) {
            low[p] = min(low[p], dfn[e[i].to]);
        }
    }
    if(dfn[p] == low[p]) {
        ++scc; int y;
        do {
            y = st[top--], ins[y] = 0;
            belong[y] = scc;// 属于哪个强连通分量
            a2[scc] += a[y];// 缩点后统计点信息
        }while(p != y);// 主要循环方式
    }
}

边双联通分量 割边

$\exists$y$\in$subtree(x)(搜索树)，且low[y] > dfn[x]，则<x,y>为割边（无向边） 边双联通分量就是不含割边的子图

bool bridge[maxe];// 割边
void tarjan(int p, int in_edge) {// tarjan求割边
    dfn[p] = low[p] = ++num;
    for(int i = head[p]; i; i = e[i].next) {
        int v1 = e[i].to;
        if(!dfn[v1]) {
            tarjan(v1, i);
            low[p] = min(low[p], low[v1]);
            if(low[v1] > dfn[p]) {// 割边判定法则 
                bridge[i] = bridge[i ^ 1] = true;
            }
        }
        else if(i != (in_edge ^ 1)) {
            low[p] = min(low[p], dfn[v1]);
        }
    } 
} 
int belong[maxn];// 属于哪个分量
vector<int>e_dcc[maxn];// 存储每个双联通分量编号和点数 
void dfs(int p) {// 边双联通分量dfs
    if(!p) return;// 防止虚无边 
    belong[p] = e_dcc_cnt;
    e_dcc[e_dcc_cnt].push_back(p);
    ++e_dcc[e_dcc_cnt][0];
    for(int i = head[p]; i; i = e[i].next) {
        if(belong[e[i].to] || bridge[i]) continue;
        dfs(e[i].to);
    }
}
// 下面代码在主函数中
for(int i = 1; i <= n; ++i) {
    if(!dfn[i]) {
        tarjan(i, 0);
    }
}
for(int i = 1; i <= n; ++i) {
    if(!belong[i]) {
        e_dcc[++e_dcc_cnt].push_back(0);
        dfs(i);
    }
}

 4.网络流

dinic最大流

不会EK算法，所以写dinic了反正dinic效率比较高。网络流注重于建模，算法为其次。

容易用反证法证明最大流=最小割，且通过建源点汇点的方式可以解决二分图最大匹配问题，等等......

bool bfs() {// 残量网络分层图
    memset(d, 0, sizeof(d));
    qhead = 1, tail = 0;
    q[++tail] = s;d[s] = 1; now[s] = head[s];// 从源点开始 
    while(tail >= qhead) {
        int p = q[qhead++];
        for(int i = head[p]; i; i = e[i].next) {
            if(e[i].v > 0 && !d[e[i].to]) {// 在网络内，没分过层 
                q[++tail] = e[i].to;
                now[e[i].to] = head[e[i].to];// 当前弧优化 
                d[e[i].to] = d[p] + 1;
                if(e[i].to == t) return 1;// 到汇点 分层成功 
            }
        }
    }
    return 0;// 记得 
}
int dinic(int p, int flow) {// 增广
    if(p == t) return flow;
    int rest = flow, temp, i;
    for(int i = now[p]; i && rest; i = e[i].next) {
        if(e[i].v > 0 && d[e[i].to] == d[p] + 1) {
            temp = dinic(e[i].to, min(rest, e[i].v));// 继续增广，取当前剩余和边限制最小值 
            if(!temp) d[e[i].to] = 0;// 剪枝，增广完不遍历 
            e[i].v -= temp;
            e[i ^ 1].v += temp;
            rest -= temp;
        }
    }
    now[p] = i;// 当前弧优化即避免遍历不可遍历边 
    return flow - rest;
}
// 下面代码在主函数中
while(bfs()) {
    while(temp = dinic(s, inf)) {
        maxflow += temp;
    }
}

ISAP最大流

虽然复杂度理论上界相比dinic没有变，但是随机数据下跑得比dinic快，也不是很难写，hlpp没有必要

void bfs() {// 只用bfs一遍
    qhead = 1, tail = 0;
    q[++tail] = t; dep[t] = 1;// 从t开始搜索
    gap[1] = 1;
    while(tail >= qhead) {
        int p = q[qhead++];
        for(int i = head[p]; i; i = e[i].next) {
            if(!dep[e[i].to]) {// 少了有流量的限制 dfs时判定就好 
                dep[e[i].to] = dep[p] + 1;
                ++gap[dep[e[i].to]];
                q[++tail] = e[i].to;
            }
        } 
    }
}
int dfs(int p, int flow) {
    if(p == t) return flow;
    int rest = flow, temp;
    for(int &i = now[p]; i; i = e[i].next) {// 因为中间要return不便修改 加& 
        if(e[i].flow && dep[p] == dep[e[i].to] + 1) {// 注意深度反过来
            temp = dfs(e[i].to, min(e[i].flow, rest));
            e[i].flow -= temp;
            e[i ^ 1].flow += temp;
            rest -= temp;
            if(!rest) return flow;// 这里表示没得增广了 
        }
    }
    // 到这里说明 1.前面传来流量还有 2.能往下传的都传完了 表明该点不能再增广 要改深度 
    // 分隔开该点出点 
    --gap[dep[p]]; 
    if(!gap[dep[p]]) dep[s] = n + 1;// 就为这句话 出现断层不用再增广
    ++dep[p];
    ++gap[dep[p]];
    return flow - rest; 
}
// 以下在主函数中
bfs();
while(dep[s] <= n) {// 只要没有断层
    memcpy(now, head, sizeof(head));// 当前弧优化 
    maxflow += dfs(s, inf);// 就一直增广 
}

没比dinic多几行

dinic费用流

费用流每次以费用为权值找最短路来增广，注意由于反向边用于撤销，费用要设为负数。具体实现就是bfs分层改成SPFA求最短路。

消圈暂时搁置。

bool SPFA() {
    memset(dis, inf, sizeof(dis));
    memcpy(now, head, sizeof(head));
    qhead = 1, tail = 0, q[++tail] = s;
    dis[s] = 0, inq[s] = 1;
//    printf("%d %d\n", t, dis[t]);
    while(tail >= qhead) {
        int p = q[qhead++];
        inq[p] = 0;
        for(int i = head[p]; i; i = e[i].next) {
            if(e[i].flow > 0 && dis[e[i].to] > dis[p] + e[i].cost) {
                dis[e[i].to] = dis[p] + e[i].cost;
                if(!inq[e[i].to]) {
                    q[++tail] = e[i].to;
                    inq[e[i].to] = 1;
                }
            }
        }
    }
    return dis[t] != inf;
}
int dinic(int p, int flow) {
    if(p == t) return flow;
    int rest = flow, i, temp;
    inq[p] = 1;// 必要的增广队列 
    for(i = now[p]; i && rest > 0; i = e[i].next) {
        if(!inq[e[i].to] && dis[e[i].to] == dis[p] + e[i].cost && e[i].flow > 0) {
            temp = dinic(e[i].to, min(rest, e[i].flow));
            if(!temp) dis[e[i].to] = -1;
            e[i].flow -= temp;
            e[i ^ 1].flow += temp;
            mincost += e[i].cost * temp;
            rest -= temp;
        }
    }
    inq[p] = 0;
    now[p] = i;
    return flow - rest;
}
// 下面代码在主函数中
while(SPFA()) {
    while((nowflow = dinic(s, inf)) != 0) {
        maxflow += nowflow;
    }
}

5.点分治

处理树上路径统计问题。日后有时间简化一下寻找重心部分。

void get_g(int p, int last) {
    sz[p] = 1;
    int max_part = 0;
    for(int i = head[p]; i; i = e[i].next) {
        if(del[e[i].to] || e[i].to == last) continue;
        get_g(e[i].to, p);
        sz[p] += sz[e[i].to];
        max_part = max(max_part, sz[e[i].to]);
    }
    max_part = max(max_part, allsz - sz[p]);
    if(max_part < gpart) {
        g = p;
        gpart = max_part;
    }
}
void dfs(int p, int last) {
    a[++top] = p;
    for(int i = head[p]; i; i = e[i].next) {
        if(e[i].to == last || del[e[i].to]) continue;
        dis[e[i].to] = dis[p] + e[i].w;
        bel[e[i].to] = bel[p];
        dfs(e[i].to, p);
    }
}
void divide(int p) {
    gpart = 0x3f3f3f3f;
    get_g(p, 0);
    bel[g] = g; dis[g] = top = 0;
    a[++top] = g; cnt[g] = 0;
    for(int i = head[g]; i; i = e[i].next) {
        if(del[e[i].to]) continue;
        dis[e[i].to] = e[i].w;
        bel[e[i].to] = e[i].to;
        cnt[e[i].to] = 0;
        dfs(e[i].to, g);
    }
    sort(a + 1, a + top + 1, cmp);
    for(int i = 1; i <= top; ++i) ++cnt[bel[a[i]]];
    int l = 1, r = top;
    while(l < r) {// 例子是双指针统计 路径长度<=k路径数
        while(dis[a[l]] + dis[a[r]] > k) --cnt[bel[a[r--]]];
        ans += r - l + 1 - cnt[bel[a[l]]];
        --cnt[bel[a[l++]]];
    }
    del[g] = 1;
    for(int i = head[g]; i; i = e[i].next) {
        if(del[e[i].to]) continue;
        allsz = sz[e[i].to];
        divide(e[i].to);
    } 
}

数学

1.exgcd 求二元一次不定方程

首先ax+by = c有整数解的充要条件是 gcd(a,b)|c （裴蜀定理，显然） 用这个可以判定方程无解情况，令d=gcd(a,b)，解方程时可以先把方程化为 (a/d)*x + (b/d) * y = c/d，再调用exgcd的函数，最后特解x2 *= c，y2 *= c即可，可以构造通解形式 x = x2 + t * b, y = y2 - t * a， 进行值域分析容易得到 $\lceil \frac{-x2+1}{b} \rceil$ <= t <= $\lfloor \frac{y2-1}{a} \rfloor$ 

对于同余方程ax $\equiv$ 1 (mod p)，构造二元一次不定方程ax + py = 1(y为 负数未知数)，解出x即可得到a在模p意义下的乘法逆元，且比费马小定理更通用，a和p互质即可

typedef long long ll;
void exgcd(ll a, ll b, ll &x, ll &y) {// 同时也相当于求解了gcd(a,b) 记得写&
    if(!b) {
        x = 1;
        y = 0;
        return;
    }
    exgcd(b, a % b, x, y);
    int temp = x;
    x = y;
    y = temp - a / b * y;// 推个式子就好了
}

 2.快速幂&龟速乘

没啥好说的，(a ^ b) % m，核心思想是二进制拆分，但是注意可能幂运算过多可能要预处理次幂，龟速乘一般用于模数比int大的情况，模数为质数时候可以用快速幂+费马小定理求乘法逆元

typedef long long ll;
ll qpow(ll a, ll b, ll m) {// 快速幂
    ll ret = 1;
    while(b) {
        if(b & 1) ret = ret * a % m;
        a = a * a % m;
        b >>= 1;
    }
    return ret;
}
ll mul(ll a, ll b, ll m) {// 龟速乘， a*b % m
    ll ret = 0;
    while(b) {
        if(b & 1) ret = (ret + a) % m;
        a = (a + a) % m;
        b >>= 1;
    }
    return ret;
}

 3.线性筛 & 积性函数

线性筛质数，还可以拿来搞积性函数递推，下面约定phi为欧拉函数，miu为莫比乌斯函数，d为约数个数函数

// prime大小要自行估计，开大点一般不会爆 
phi[0] = phi[1] = 1;// 千万记得初始化
miu[1] = 1;
d[1] = 1;
for(int i = 2; i <= n; ++i) {
    if(!isntp[i]) {
        prime[++cnt] = i;
        phi[i] = i - 1;
        miu[i] = -1;
        d[i] = 2;// 对于约数函数，可以考虑使用唯一分解+乘法原理 
        num[i] = 1;// num[i]为i当前质因数次幂 
    }
    for(int j = 1; j <= cnt; ++j) {
        int k = i * prime[j];
        if(k > n) break;
        isntprime[k] = 1;
        if(i % prime[j] == 0) {
            phi[k] = phi[i] * prime[j];// k包含i所有质因子 
            miu[k] = 0;
            num[k] = num[i] + 1;
            d[k] = d[i] / num[k] * (num[k] + 1);
            break;
        }
        // 互质 积性递推 
        phi[k] = phi[i] * phi[prime[j]]; 
        miu[k] = -miu[i];
        d[k] = d[i] << 1;
        num[k] = 1;
    }
}

4.乘法逆元

乘法逆元一般多个数递推比较有用，可以拿来算组合数之类的

void exgcd(int a, int b, int &x, int &y) {
    if(!b) {x = 1; y = 0; return;}
    exgcd(b, a % b, x, y);
    int temp = x;
    x = y;
    y = temp -a / b * x;
}
int inv(int a,int p) {
    int x0,y0;
    exgcd(a, p, x0, y0);
    return (x0 % p + p) % p;// 防止负数
}
// 下面在主函数内
s[0] = 1;// 前缀积
for(int i = 1; i <= n; ++i) {
    scanf("%d", a + i);// 特别是a[i] = i 时可以预处理阶乘逆元
    s[i] = 1ll * s[i-1] * a[i] % p;
}
vs[n] = inv(s[n],p);
for(int i = n - 1; i >= 1; --i) vs[i] = 1ll * vs[i+1] * a[i+1] % p;
// 考虑把式子写成倒数形式就可以了
for(int i = 1; i <= n; ++i) {
    inva[i] = 1ll * vs[i] * s[i-1] % p;
}

5.CRT & EXCRT

crt就是基于基于一个公式 x = $\sum_{i=1}^n a_i M_i t_i$ Mi就是所有$m_i$（每个方程模数）乘起来除以当前mi，ti就是 $M_i t_i \equiv 1$(mod $m_i$) 的解，$a_i$就是原方程右边的数

要求mi两两之间互质，显然有限制

excrt就是推式子，用exgcd将方程之间两两合并，维护前缀最大公约数，原本的解加上t * M, 解出t然后回带，有些题换汤不换药，就比如NOI2018 屠龙勇士

// CRT
for(int i = 1; i <= n; ++i) {
    M[i] = Mm / m[i];
    exgcd(M[i], m[i], x0, y0);
    t[i] = (x0 % m[i] + m[i]) % m[i];
}
for(int i = 1; i <= n; ++i) x += a[i] * M[i] * t[i];
//EXCRT
for(int i = 2; i <= n; ++i) {
    tempgcd = gcd(prelcm, m[i]);
    tempc = (a[i] - nowx % m[i] + m[i]) % m[i];
    exgcd(prelcm, m[i], tempx, tempy);
    tempx = mul(tempx, tempc / tempgcd, m[i] / tempgcd);
    nowx = nowx + tempx * prelcm;
    prelcm = prelcm / tempgcd * m[i];
    nowx = (nowx % prelcm + prelcm) % prelcm;
}

6.BSGS ex待补

拿来解方程 $ a^x \equiv b$ (mod p)，a、p互质，实质是枚举法的改进，根号根号地枚举，最后验证

我好像也不太知道这玩意能拿来干嘛

int BSGS(int a, int b, int p) {// 无解返回-1
    b %= p;
    int t = (int)sqrt(p) + 1;
    for(int j = 0; j < t; ++j) {
        hs.insert(1ll * b * ksm(a, j, p) % p, j);// 拉链法哈希表 考试就写unordered_map吧
    }
    a = ksm(a, t, p);
    if(!a) return b == 0 ? 1 : -1;
    for(int i = 0; i <= t; ++i) {
        int val = ksm(a, i, p);
        int j = hs.find(val);
        if(j >= 0 && i * t - j >= 0) return i * t - j;
    }
    return -1;
}

7.矩阵乘法

什么年代了还在考传统矩阵乘法，看见有min{},+，&，|，这种有结合律的东西就考虑下矩阵乘法（GZOI2017 河神）

struct matrix {
    ll mat[11][11];
    void clear() {
        for(int i = 1; i <= 10; ++i)
            memset(mat[i], 0, sizeof(mat[i]));
    }
    ll *operator [] (int index) {
        return mat[index];
    }
    matrix operator * (const matrix &m2) {
        matrix ret; ret.clear();
        for(int i = 1; i <= 10; ++i) {
            for(int k = 1; k <= 10; ++k) {
                ll temp = mat[i][k];
                for(int j = 1; j <= 10; ++j) {
                    ret[i][j] = (ret[i][j] + temp * m2.mat[k][j] % mod) % mod;
                }
            }
        }
        return ret;
    }
    friend matrix operator ^ (matrix m1, ll k) {
        matrix ret; ret.clear();
        for(int i = 1; i <= 10; ++i) 
            ret[i][i] = 1;
        while(k) {
            if(k & 1) ret = ret * m1;
            m1 = m1 * m1;
            k >>= 1;
        }
        return ret;
    }
}a1,ans;

8.高斯消元

拿来解线性方程组，还有矩阵求逆、求行列等作用，还可以优化成环的期望dp

都不想吐槽之前写的高斯消元什么答辩玩意，换了高斯-约旦消元法，精度更好，代码更短

bool gauss() {
    for(short i = 1; i <= n; ++i) {
        int mxj = i;
        for(short j = i; j <= n; ++j) if(fabs(a[j][i]) > fabs(a[mxj][i])) mxj = j;// 这里可以减小误差
        swap(a[mxj], a[i]);
        if(fabs(a[i][i]) < eps) {
            printf("No Solution");
            return false;
        }
        for(short j = 1; j <= n; ++j) {
            if(j == i) continue;
            double rate = a[j][i] / a[i][i];
            for(short k = i; k <= n + 1; ++k) a[j][k] = a[j][k] - a[i][k] * rate;
        }
    }
    return true;
}

高斯消元求行列式

就是消成只剩主对角线，乘起来即可，注意行列式交换两行值要取反

模数为质数，保证逆元存在的版本

int getdet() {
        int ret = 1, fh = 1;
        for(short i = 1; i <= li; ++i) {
            for(short j = i; j <= li; ++j) 
                if(mat[j][i]) {
                    if(i != j) swap(mat[i], mat[j]), fh = -fh;
                    break;
                }
            for(short j = 1; j <= li; ++j) {
                if(j == i || !mat[j][i]) continue;
                int rate = 1ll * mat[j][i] * ksm(mat[i][i], mod - 2) % mod;
                for(short k = 1; k <= li; ++k) mat[j][k] = (mat[j][k] - 1ll * mat[i][k] * rate % mod) % mod;
            }
        }
        for(short i = 1; i <= li; ++i) ret = 1ll * ret * mat[i][i] % mod;
        return (ret * fh + mod) % mod;
    }

模数不保证是质数的版本

for(short i = 1; i <= n; ++i) {
        for(short j = i + 1; j <= n; ++j) {
            while(a[i][i]) {
                int rate = a[j][i] / a[i][i];
                for(short k = 1; k <= n && rate; ++k) a[j][k] = (a[j][k] - 1ll * rate * a[i][k] % p) % p;
                swap(a[i], a[j]);
                fh = -fh;
            }
            swap(a[i], a[j]);
            fh = -fh;
        }
    }
    for(short i = 1; i <= n; ++i) ans = 1ll * ans * a[i][i] % p;
    ans *= fh;

 9.线性基

线性基可以搞比如一堆数异或起来可得到的最大，最小，第k大值，判断一个数能不能由某些数异或得到

核心思想是每次高斯消元消掉最高位

异或版

查询存不存在就遍历一遍，当前数如果与当前基底的这一位都是1就异或掉这个基底，最后看是不是0

void insert(ll x) {// 插入
    for(int i = maxbit; i >= 0; --i) {// maxbit最高位
        if(x >> i & 1) {
            if(!lb[i]) {
                lb[i] = x;
                ++cnt;
                break;
            }
            else x ^= lb[i];
            if(!x) {
                zero = 1;
                break;
            }
        }
    }
}
void work() {// 如果查询第k大要高斯消元要化为最简形
    for(int i = 0; i <= 60; ++i) {
        if(!lb[i]) continue;
        for(int j = i + 1; j <= 60; ++j) {
            if(lb[j] >> i & 1) lb[j] ^= lb[i];
        }
    } 
}
ll kth(ll k) {
    ll ret = 0;
    if(zero) --k;
    if(k >= (1ll << cnt)) return -1; 
    for(int i = 0; i <= cnt - 1; ++i)
        if(k >> i & 1) ret ^= lb[i];
    return ret;
}
ll max_num(ll x) {// 最大值
    for(int i = maxbit; i >= 0; --i) {
        if((x ^ lb[i]) > x) x ^= lb[i];
    }
    return x;
}
// 最小值就是线性基中最小的数

实数版

struct real_vector {
    int v[505],c;
    friend real_vector operator * (real_vector v1, const int &x) {
        for(short i = 1; i <= m; ++i) {
            if(!v1.v[i]) continue;
            v1.v[i] = 1ll * v1.v[i] * x % mod;
        }
        return v1;
    }
    friend real_vector operator - (real_vector v1, const real_vector &v2) {
        for(short i = 1; i <= m; ++i) {
            v1.v[i] = ((v1.v[i] - v2.v[i]) % mod + mod) % mod;// 由于JLOI那个题过于鬼畜所以要上取模
        }
        return v1;
    }
}b[505],lb[505];
void insert(int x) {
    bool flag = 0;
    for(short i = m; i >= 1; --i) {
        if(b[x].v[i]) {
            if(!lb[i].v[i]) {
                lb[i] = b[x];
                flag = 1;
                ++ans1;
                ans2 += b[x].c;
                break;
            }
            else b[x] = b[x] - (lb[i] * (1ll * b[x].v[i] * inv(lb[i].v[i]) % mod));// 核心思想是消去最高位 inv逆元
            if(ept(x)) break;// ept表示0向量
        }
    }
}

10.多项式

生成函数的基础。闲的没事偶尔抽点时间完善一下多项式全家桶。

FFT

注意的细节：

1.逆变换除以长度

2.不要三次变两次，精度小心被卡爆，同时能用NTT的题绝对不用FFT

3.用于蝴蝶操作的r/rev数组递推不要写错

4.最高次为m，n的两个多项式相乘，最高次数m+n，我们要变化到$2^{x} >= m + n, x \in \mathbb{Z}$

void fft(int lim, complex *f, int type){// 1系数变点，-1点变系数，complex手写复数类 
    for(int i = 0; i < lim; ++i) if(i < r[i]) swap(f[i], f[r[i]]);
    for(int len = 2; len <= lim; len <<= 1) {
        complex wn = {cos(2 * pi / len), type * sin(2 * pi / len)};
        for(int i = 0; i < lim; i += len) {
            complex wnk = {1, 0};
            for(int j = i; j < i + (len >> 1); ++j, wnk = wnk * wn) {
                complex u = f[j], t = f[j + (len >> 1)] * wnk;
                f[j] = u + t;
                f[j + (len >> 1)] = u - t;
            }
        }
    }
}
// 注意这个版本是没有预处理单位根的
// 对于每个len处理出所有对应单位根会更快 

 NTT

注意的细节：

1.该取模的一个都不能少，该乘1ll的一个都不能忘

2.gp[0] = 1

void ntt(int lim, int *f, int type) {// 1系数变点，-1点变系数
    for(int i = 0; i < lim; ++i)
        if(i < r[i]) swap(f[i], f[r[i]]);
    for(int len = 2; len <= lim; len <<= 1) {
        gp[1] = ksm(type == 1 ? g : g_1, (p - 1) / len, p);
        for(int i = 2; i < (len >> 1); ++i) gp[i] = 1ll * gp[i - 1] * gp[1] % p;// 预处理单位根 忘取模草 
        for(int i = 0; i < lim; i += len) {
            for(int j = i; j < i + (len >> 1); ++j) {// 这里要反复使用单位原根 可以预处理 
                int u = f[j],t = 1ll * f[j + (len >> 1)] * gp[j - i] % p;
                f[j] = (u + t) % p;
                f[j + (len >> 1)] = (u - t + p) % p;
            }
        }
    }
    if(type == -1) {//逆变换除以长度 费马小定理乘法逆元 
        int inv = ksm(lim, p - 2, p);
        for(int i = 0; i < lim; ++i) f[i] = 1ll * f[i] * inv % p;
    }
}

封装多项式乘法

void init() {
    sx = 1, l = -1;
    while(sx <= n + m) sx <<= 1, ++l;
    for(int i = 0; i < sx; ++i) rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << l);
    gp[0] = 1;
}
int A[maxn],B[maxn];
void mul(int *a, int *b, int lim) {// a(x) * b(x) 存在a(x)上
    memset(A, 0, sizeof(A));
    memset(B, 0, sizeof(B));
    for(int i = 0; i < lim; ++i) A[i] = a[i], B[i] = b[i];
    ntt(A, lim, 1); ntt(B, lim, 1);
    for(int i = 0; i < lim; ++i) A[i] = 1ll * A[i] * B[i] % p;
    ntt(A, lim, -1);
    for(int i = 0; i < lim; ++i) a[i] = A[i];
}

  多项式乘法逆

考虑倍增计算，简单数学推导一下即可，自认为常数卡得还可以(?)。就是细节有点多

1.rev数组重新计算

2.注意多项式的界，超过清零

void polyinv(int *a, int *b, int lim) {
    if(lim == 1) {
        b[0] = ksm(a[0], p - 2);
        return;
    }
    polyinv(a, b, (lim + 1) >> 1);
    int sx = 1, l = -1;
    while(sx <= (lim << 1)) sx <<= 1, ++l;
    for(int i = 0; i < sx; ++i) rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << l);//error2
    for(int i = 0; i < lim; ++i) c[i] = a[i];
    for(int i = lim; i < sx; ++i) c[i] = 0;
    ntt(c, sx, 1); ntt(b, sx, 1);
    for(int i = 0; i < sx; ++i)// 求逆的高级操作 不用卷两次 
        b[i] = 1ll * b[i] * (2 - 1ll * c[i] * b[i] % p + p) % p;
    ntt(b, sx, -1);
    for(int i = lim; i < sx; ++i) b[i] = 0;
}

多项式ln

先求导再积分 解决了

void qiudao(int *a, int *b, int lim) {
    for(int i = 0; i < lim; ++i) b[i] = 1ll * a[i + 1] * (i + 1) % p;
    b[lim - 1] = 0;
}
void jifen(int *a, int *b, int lim) {
    for(int i = 1; i < lim; ++i) b[i] = 1ll * a[i - 1] * ksm(i, p - 2) % p;
    b[0] = 0;
}
int d[maxn],e[maxn];
void polyln(int *a, int *b, int lim) {
    qiudao(a, d, lim); polyinv(a, e, lim);
    int sx = 1, l = -1;
    while(sx <= (lim << 1)) sx <<= 1, ++l;
    for(int i = 0; i < sx; ++i) rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << l);
    ntt(d, sx, 1); ntt(e, sx, 1);
    for(int i = 0; i < sx; ++i) d[i] = 1ll * d[i] * e[i] % p;
    ntt(d, sx, -1);
    jifen(d, b, lim);
}