add: 文艺平衡树, 左偏树, 主席树, 树上差分, 树上启发式合并, 重链剖分, 最近公共祖先, 线段树合并, Tarjan

Author: nephrenn233

README.md

@@ -1,14 +1,23 @@
 # Templates-in-Competitive-Programming
 
 自用算法竞赛模板，来源于我自己和网络。
-附有 LaTex 生成的 pdf 版本。
+
+由于代码时间跨度较大，来源较多，代码风格存在差异。
+
+附有 LaTex 生成的 pdf 版本，使用 [ply-template](https://github.com/palayutm/ply-template) 模板生成。
 
 ## 数据结构 data structure
 
 + 树状数组 (Fenwick Tree.cpp)，支持单点修改、前缀和查询
 + 并查集 (Disjoint Set Union.cpp)，支持查询集合、查询集合大小、合并
 + FHQ Treap (FHQ Treap.cpp)，支持插入、删除、按值查询排名、按排名查询值、查询前驱后继
+    + 文艺平衡树 (Interval Reverse.cpp)，维护区间翻转
 + ST 表 (ST.cpp)
++ 左偏树 (Lefist Tree.cpp)，可合并堆
++ 主席树
+    + 静态区间第 k 小 (Persistent Segment Tree.cpp)
+    + 静态区间颜色数 (Static Interval Color.cpp)
+    + 静态区间 mex (Static Interval Mex.cpp)
 
 ## 数学 math
 
@@ -28,6 +37,20 @@
 + Trie (Trie.cpp)
 + 字符串哈希 (String Hash.cpp)
 
+## 图论 graph theory
+
++ 线段树合并 (Segment Tree Merge.cpp)
++ 树上启发式合并 (Dsu On Tree.cpp)
++ 重链剖分 (Heavy-light Decomposition.cpp)
++ 最近公共祖先
+    + 倍增做法 (LCA1.cpp)
+    + 重链剖分做法 (LCA2.cpp)
++ 树上差分 (Difference On Tree.cpp)
++ 连通性相关
+    + 割点 (Tarjan1.cpp)
+    + 点双连通分量 (Tarjan2.cpp)
+    + 边双连通分量 (Tarjan3.cpp)
+
 ## 杂项 various
 
 + 取模类 (ModInt.cpp)

data structure/Interval Reverse.cpp

@@ -0,0 +1,106 @@
+std::random_device seed;
+std::mt19937 rnd(seed());
+
+int n, q;
+
+struct node
+{
+	int sz, key, val, ls, rs, lazy;
+}tree[MAXN];
+int rt, tot, t1, t2, t3;
+
+int new_node(int v)
+{
+	tree[++tot] = {1, int(rnd()), v, 0, 0, 0};
+	return tot;
+}
+
+void push_up(int u)
+{
+	tree[u].sz = tree[tree[u].ls].sz + tree[tree[u].rs].sz + 1;
+}
+
+void push_down(int u)
+{
+	if(tree[u].lazy)
+	{
+		std::swap(tree[u].ls, tree[u].rs);
+		if(tree[u].ls) tree[tree[u].ls].lazy ^= 1;
+		if(tree[u].rs) tree[tree[u].rs].lazy ^= 1;
+		tree[u].lazy = 0;
+	}
+}
+
+void split_by_rnk(int u, int k, int &x, int &y)
+{
+	if(!u)
+	{
+		x = y = 0;
+		return;
+	}
+	int t = tree[tree[u].ls].sz + 1;
+	push_down(u);
+
+	if(tree[tree[u].ls].sz + 1 <= k)
+	{
+		x = u;
+		split_by_rnk(tree[u].rs, k - tree[tree[u].ls].sz - 1, tree[u].rs, y);
+	}
+	else
+	{
+		y = u;
+		split_by_rnk(tree[u].ls, k, x, tree[u].ls);
+	}
+
+	push_up(u);
+}
+
+int merge(int x, int y)
+{
+	if(!x || !y) return x + y;
+
+	if(tree[x].key > tree[y].key)
+	{
+		push_down(x);
+		tree[x].rs = merge(tree[x].rs, y);
+		push_up(x);
+		return x;
+	}
+	else
+	{
+		push_down(y);
+		tree[y].ls = merge(x, tree[y].ls);
+		push_up(y);
+		return y;
+	}
+}
+
+void dfs(int u)
+{
+	if(!u) return;
+	push_down(u);
+	dfs(tree[u].ls);
+	std::cout << tree[u].val << " ";
+	dfs(tree[u].rs);
+}
+
+void solve()
+{
+	std::cin >> n >> q;
+	for(int i = 1; i <= n; ++i)
+	{
+		rt = merge(rt, new_node(i));
+	}
+
+	while(q--)
+	{
+		int l, r;
+		std::cin >> l >> r;
+		split_by_rnk(rt, r, t1, t2);
+		split_by_rnk(t1, l - 1, t1, t3);
+		tree[t3].lazy ^= 1;
+		rt = merge(merge(t1, t3), t2);
+	}
+
+	dfs(rt);
+}

data structure/Lefist Tree.cpp

@@ -0,0 +1,38 @@
+struct node
+{
+    int fa, lt, rt, val, dist;
+}ltree[MAXN];
+
+int n, m;
+int opt, x, y;
+
+int find(int x)
+{
+    return (fa(x) == x ? x : fa(x) = find(fa(x)));
+}
+
+int merge(int x, int y)
+{
+    if(!x | !y) return x | y; // 空结点
+
+    if(val(x) > val(y)) swap(x, y);
+
+    rs(x) = merge(rs(x), y);
+
+    // 维护左偏树性质
+    if(dist(ls(x)) < dist(rs(x))) swap(ls(x), rs(x));
+
+    // 维护dist和并查集
+    dist(x) = dist(rs(x)) + 1;
+    fa(ls(x)) = fa(rs(x)) = fa(x) = x;
+
+    return x;
+}
+
+void pop(int x)
+{
+    val(x) = -1;
+    fa(ls(x)) = ls(x);
+    fa(rs(x)) = rs(x);
+    fa(x) = merge(ls(x), rs(x));
+}

data structure/Persistent Segment Tree.cpp

@@ -0,0 +1,44 @@
+int n, q, a[MAXN];
+int m, b[MAXN];
+
+struct node
+{
+    LL sum, ls, rs;
+}tree[MAXN << 5];
+LL tot = 0, rt[MAXN];
+
+void build_tree(LL &u, LL l, LL r)
+{
+    u = ++tot;
+    if(l == r) return;
+    LL mid = (l + r) >> 1;
+    build_tree(tree[u].ls, l, mid);
+    build_tree(tree[u].rs, mid + 1, r);
+}
+
+LL clone(LL u)
+{
+    tree[++tot] = tree[u];
+    return tot;
+}
+
+LL modify(LL u, LL l, LL r, LL qp)
+{
+    u = clone(u);
+    tree[u].sum += 1;
+    if(l == r) return u;
+    LL mid = (l + r) >> 1;
+    if(qp <= mid) tree[u].ls = modify(tree[u].ls, l, mid, qp);
+    else tree[u].rs = modify(tree[u].rs, mid + 1, r, qp);
+    return u;
+}
+
+LL query(LL u, LL v, LL l, LL r, LL k)
+{
+    if(l == r) return l;
+    LL x = tree[tree[v].ls].sum - tree[tree[u].ls].sum;
+    LL res = 0, mid = (l + r) >> 1;
+    if(x >= k) res = query(tree[u].ls, tree[v].ls, l, mid, k);
+    else res = query(tree[u].rs, tree[v].rs, mid + 1, r, k - x);
+    return res;
+}

data structure/Static Interval Color.cpp

@@ -0,0 +1,56 @@
+int n, a[MAXN], q;
+
+int last[MAXN], nxt[MAXN];
+
+struct node
+{
+	int ls, rs, val;
+}tree[MAXN << 5];
+int rt[MAXN], tot = 0;
+
+int modify(int u, int l, int r, int x)
+{
+	tree[++tot] = tree[u];
+	u = tot;
+	tree[u].val += 1;
+
+	if(l == r) return u;
+	int mid = (l + r) >> 1;
+	if(x <= mid) tree[u].ls = modify(tree[u].ls, l, mid, x);
+	else tree[u].rs = modify(tree[u].rs, mid + 1, r, x);
+	return u;
+}
+
+int query(int u, int v, int l, int r, int x)
+{
+	if(l == r) return tree[v].val - tree[u].val;
+	int mid = (l + r) >> 1;
+	if(x <= mid) return query(tree[u].ls, tree[v].ls, l, mid, x) + tree[tree[v].rs].val - tree[tree[u].rs].val;
+	else return query(tree[u].rs, tree[v].rs, mid + 1, r, x);
+}
+
+void solve()
+{
+	cin >> n;
+	for(int i = 1; i <= n; ++i) cin >> a[i];
+
+	fill(nxt + 1, nxt + 1 + n, n + 1);
+	for(int i = 1; i <= n; ++i)
+	{
+		if(last[a[i]]) nxt[last[a[i]]] = i;
+		last[a[i]] = i;
+	}
+
+	for(int i = 1; i <= n; ++i)
+	{
+		rt[i] = modify(rt[i - 1], 1, n + 1, nxt[i]);
+	}
+
+	cin >> q;
+	while(q--)
+	{
+		int l, r;
+		cin >> l >> r;
+		cout << query(rt[l - 1], rt[r], 1, n + 1, r + 1) << "\n";
+	}
+}

data structure/Static Interval Mex.cpp

@@ -0,0 +1,67 @@
+int n, m, a[MAXN];
+
+struct node
+{
+    int ls, rs, val;
+}tree[MAXN << 5];
+int rt[MAXN], tot = 0;
+
+int build_tree(int u, int l, int r)
+{
+    u = ++tot;
+    if(l == r)
+    {
+        tree[u].val = INF;
+        return u;
+    }
+    int mid = (l + r) >> 1;
+    tree[u].ls = build_tree(tree[u].ls, l, mid);
+    tree[u].rs = build_tree(tree[u].rs, mid + 1, r);
+    return u;
+}
+
+void push_up(int u)
+{
+    tree[u].val = min(tree[tree[u].ls].val, tree[tree[u].rs].val);
+}
+
+int modify(int u, int l, int r, int qp, int k)
+{
+    tree[++tot] = tree[u];
+    u = tot;
+    if(l == r)
+    {
+        tree[u].val = k;
+        return u;
+    }
+    int mid = (l + r) >> 1;
+    if(qp <= mid) tree[u].ls = modify(tree[u].ls, l, mid, qp, k);
+    else tree[u].rs = modify(tree[u].rs, mid + 1, r, qp, k);
+    push_up(u);
+    return u;
+}
+
+int query(int u, int l, int r, int x)
+{
+    if(l == r) return l;
+    int mid = (l + r) >> 1;
+    if(tree[tree[u].ls].val < x) return query(tree[u].ls, l, mid, x);
+    else return query(tree[u].rs, mid + 1, r, x);
+}
+
+void solve()
+{
+    cin >> n >> m;
+    // rt[0] = build_tree(rt[0], 0, N);
+    for(int i = 1; i <= n; ++i)
+    {
+        cin >> a[i];
+        rt[i] = modify(rt[i - 1], 0, N, a[i], i);
+    }
+    while(m--)
+    {
+        int l, r;
+        cin >> l >> r;
+        cout << query(rt[r], 0, N, l) << "\n";
+    }
+}

graph theory/Difference On Tree.cpp

@@ -0,0 +1,8 @@
+// 边差分
+d[u] += 1, d[v] += 1;
+d[lca(u, v)] -= 2;
+
+// 点差分
+d[u] += 1, d[v] += 1;
+d[lca(u, v)] -= 1;
+d[fa[lca(u, v)]] -= 1;