Generated Automatically by Workflow.

Author: Heartfirey

PDFDocument/part1-Math.pdf

@@ -346,8 +346,11 @@ \subsubsection{区间加/区间求和}\label{ux533aux95f4ux52a0ux533aux95f4ux6c4
 }
 \end{minted}
 
+\hypertarget{ux7ebfux6bb5ux6811ux6a21ux677f}{%
+\subsection{5.线段树模板}\label{ux7ebfux6bb5ux6811ux6a21ux677f}}
+
 \hypertarget{ux6734ux7d20ux7ebfux6bb5ux6811}{%
-\subsection{4.朴素线段树}\label{ux6734ux7d20ux7ebfux6bb5ux6811}}
+\subsubsection{(1).朴素线段树}\label{ux6734ux7d20ux7ebfux6bb5ux6811}}
 
 区间和：区间修改/单点修改/单点查询/区间查询
 
@@ -419,7 +422,7 @@ \subsection{4.朴素线段树}\label{ux6734ux7d20ux7ebfux6bb5ux6811}}
 \end{minted}
 
 \hypertarget{ux52a8ux6001ux5f00ux70b9ux7ebfux6bb5ux6811}{%
-\subsection{5.动态开点线段树}\label{ux52a8ux6001ux5f00ux70b9ux7ebfux6bb5ux6811}}
+\subsubsection{(2).动态开点线段树}\label{ux52a8ux6001ux5f00ux70b9ux7ebfux6bb5ux6811}}
 
 \begin{minted}[fontsize=\footnotesize,breaklines,linenos]{cpp}
 namespace SegmentTree{
@@ -1942,8 +1945,8 @@ \subsection{13.CDQ 分治}\label{cdq-ux5206ux6cbb}}
 
 \end{minted}
 
-\hypertarget{ux73c2ux6735ux8389ux6811ux8001ux53f8ux673aux6811}{%
-\subsection{14.珂朵莉树/老司机树}\label{ux73c2ux6735ux8389ux6811ux8001ux53f8ux673aux6811}}
+\hypertarget{ux73c2ux6735ux8389ux6811ux8001ux53f8ux673aux6811ux533aux95f4ux63a8ux5e73}{%
+\subsection{14.珂朵莉树/老司机树(区间推平)}\label{ux73c2ux6735ux8389ux6811ux8001ux53f8ux673aux6811ux533aux95f4ux63a8ux5e73}}
 
 \begin{minted}[fontsize=\footnotesize,breaklines,linenos]{cpp}
 struct node{
@@ -2035,8 +2038,319 @@ \subsection{14.珂朵莉树/老司机树}\label{ux73c2ux6735ux8389ux6811ux8001ux
 }
 \end{minted}
 
+\hypertarget{ux66ffux7f6aux7f8aux6811ux66b4ux529bux91cdux6784ux4e8cux53c9ux641cux7d22ux6811}{%
+\subsection{15.替罪羊树(暴力重构二叉搜索树)}\label{ux66ffux7f6aux7f8aux6811ux66b4ux529bux91cdux6784ux4e8cux53c9ux641cux7d22ux6811}}
+
+很暴力但是很牛逼的结构，平衡系数一般置为\(0.75\)即可。注意，二叉搜索树本质不变，所有二叉搜索树性质仍然适用。
+
+平衡系数越大插入速度就越快，而访问和删除速度就会降低。反之则插入变慢
+
+\begin{minted}[fontsize=\footnotesize,breaklines,linenos]{cpp}
+const int N = 2e5 + 10;
+double alpha = 0.75;    //平衡系数
+
+namespace SGT {
+    struct node {
+        int ls, rs;
+        int w, wn, s, sz, sd;
+    } tree[N];
+    
+    int cnt, root;
+    
+    //* recalculate the value of rt 
+    void calc(int rt) {
+        tree[rt].s = tree[tree[rt].ls].s + tree[tree[rt].rs].s + 1;
+        tree[rt].sz = tree[tree[rt].ls].sz + tree[tree[rt].rs].sz + tree[rt].wn;
+        tree[rt].sd = tree[tree[rt].ls].sd + tree[tree[rt].rs].sd + (tree[rt].wn != 0);
+    }
+
+    //* determine if node k needs to be rebuild
+    bool can_rebuild(int rt) {
+        return tree[rt].wn && (alpha * tree[rt].s <= (double)max(tree[tree[rt].ls].s, tree[tree[rt].rs].s) || (double)tree[rt].sd <= alpha * tree[rt].s);   
+    }
+
+    int ldr[N];
+
+    //* flatten the sub-tree of node rt in medium-order traversal
+    void rebuild_nf(int &ldc, int rt) {
+        if(!rt) return;
+        rebuild_nf(ldc, tree[rt].ls);
+        if(tree[rt].wn) ldr[ldc++] = rt;
+        rebuild_nf(ldc, tree[rt].rs); // if the current node has been deleted, then no retained it.
+    }
+
+    //* rebuild the part [l, r] to a binary search tree(in array ldr)
+    int rebuild_bd(int l, int r) {
+        if(l >= r) return 0;
+        int mid = l + r >> 1;   // choose the mid value as the root to make it balanced
+        tree[ldr[mid]].ls = rebuild_bd(l, mid);
+        tree[ldr[mid]].rs = rebuild_bd(mid + 1, r);
+        calc(ldr[mid]);
+        return ldr[mid];
+    }
+
+    //* rebuild the sub-tree of node rt
+    void rebuild(int &rt) {
+        int ldc = 0;
+        rebuild_nf(ldc, rt);
+        rt = rebuild_bd(0, ldc);
+    }
+
+    //* insert a node ot the subtree of rt with value k
+    void insert(int &rt, int k) {
+        if(!rt) {
+            rt = ++cnt;
+            if(!root) root = 1;
+            tree[rt].w = k;
+            tree[rt].ls = tree[rt].rs = 0;
+            tree[rt].wn = tree[rt].s = tree[rt].sz = tree[rt].sd = 1;
+        } else {
+            if(tree[rt].w == k) tree[rt].wn++;
+            else if(tree[rt].w < k) insert(tree[rt].rs, k);
+            else insert(tree[rt].ls, k);
+            calc(rt);
+            if(can_rebuild(rt)) rebuild(rt);
+        }
+    }
+
+    //* delete the node with value k from the sub-tree of k
+    void del(int &rt, int k) {
+        if(!rt) return;
+        if(tree[rt].w == k) {
+            if(tree[rt].wn) tree[rt].wn--;
+        } else {
+            if(tree[rt].w < k) del(tree[rt].rs, k);
+            else del(tree[rt].ls, k);
+        }
+        calc(rt);
+        if(can_rebuild(rt)) rebuild(rt);
+    }
+    
+    //* find the lowest ranking with a weight strictly greater than k
+    int upper_min(int rt, int k) {
+        if(!rt) return 1;
+        else if(tree[rt].w == k && tree[rt].wn)
+            return tree[tree[rt].ls].sz + tree[rt].wn + 1;
+        else if(tree[rt].w > k)
+            return upper_min(tree[rt].ls, k);
+        else
+            return tree[tree[rt].ls].sz + tree[rt].wn + upper_min(tree[rt].rs, k);
+    }
+
+    //* find the maximum ranking with a weight strictly less than k
+    int lower_max(int rt, int k) {
+        if(!rt) return 0;
+        else if(tree[rt].w == k && tree[rt].wn)
+            return tree[tree[rt].ls].sz;
+        else if(tree[rt].w < k)
+            return tree[tree[rt].ls].sz + tree[rt].wn + lower_max(tree[rt].rs, k);
+        else
+            return lower_max(tree[rt].ls, k);
+    }
+    
+    //* find the exactly value of rank k
+    int getk(int rt, int k) {
+        if(!rt) return 0;
+        else if(tree[tree[rt].ls].sz < k && k <= tree[tree[rt].ls].sz + tree[rt].wn)
+            return tree[rt].w;
+        else if(tree[tree[rt].ls].sz + tree[rt].wn < k)
+            return getk(tree[rt].rs, k - tree[tree[rt].ls].sz - tree[rt].wn);
+        else
+            return getk(tree[rt].ls, k);
+    }
+
+    inline int find_pre(int rt, int k) {
+        return getk(rt, lower_max(rt, k));
+    }
+
+    inline int find_aft(int rt, int k) {
+        return getk(rt, upper_min(rt, k));
+    }
+}
+
+using SGT::root;
+
+inline void solve() {
+    int n = 0; cin >> n;
+    for(int i = 1; i <= n; i++) {
+        int op, x; cin >> op >> x;
+        if(op == 1) SGT::insert(root, x);
+        else if(op == 2){
+            SGT::del(root, x);
+        }
+        else if(op == 3) {
+            int rnk = SGT::lower_max(root, x) + 1;
+            cout << rnk << endl;
+        } else if(op == 4) {
+            int k = SGT::getk(root, x);
+            cout << k << endl;
+        } else if(op == 5) {
+            int pre = SGT::find_pre(root, x);
+            cout << pre << endl;
+        } else if(op == 6) {
+            int aft = SGT::find_aft(root, x);
+            cout << aft << endl;
+        }
+    }
+}
+\end{minted}
+
+\hypertarget{splay}{%
+\subsection{16.Splay}\label{splay}}
+
+\begin{minted}[fontsize=\footnotesize,breaklines,linenos]{cpp}
+#include <cstdio>
+const int N = 100005;
+int rt, tot, fa[N], ch[N][2], val[N], cnt[N], sz[N];
+
+struct Splay{
+    void maintain(int x) { sz[x] = sz[ch[x][0]] + sz[ch[x][1]] + cnt[x]; }
+
+    bool get(int x) { return x == ch[fa[x]][1]; }
+
+    void clear(int x) {
+        ch[x][0] = ch[x][1] = fa[x] = val[x] = sz[x] = cnt[x] = 0;
+    }
+
+    void rotate(int x){
+        int y = fa[x], z = fa[y], chk = get(x);
+        ch[y][chk] = ch[x][chk ^ 1];
+        if (ch[x][chk ^ 1])  fa[ch[x][chk ^ 1]] = y;
+        ch[x][chk ^ 1] = y;
+        fa[y] = x, fa[x] = z;
+        if (z) ch[z][y == ch[z][1]] = x;
+        maintain(x), maintain(y);
+    }
+
+    void splay(int x){
+        for (int f = fa[x]; f = fa[x], f; rotate(x))
+            if (fa[f]) rotate(get(x) == get(f) ? f : x);
+        rt = x;
+    }
+
+    void insert(int k){
+        if (!rt){
+            val[++tot] = k, cnt[tot]++;
+            rt = tot;
+            maintain(rt);
+            return;
+        }
+        int cur = rt, f = 0;
+        while (1){
+            if (val[cur] == k){
+                cnt[cur]++;
+                maintain(cur), maintain(f);
+                splay(cur);
+                break;
+            }
+            f = cur, cur = ch[cur][val[cur] < k];
+            if (!cur){
+                val[++tot] = k, cnt[tot]++, fa[tot] = f;
+                ch[f][val[f] < k] = tot;
+                maintain(tot), maintain(f);
+                splay(tot);
+                break;
+            }
+        }
+    }
+
+    int rk(int k){
+        int res = 0, cur = rt;
+        while (1){
+            if (k < val[cur]){
+                cur = ch[cur][0];
+            }
+            else{
+                res += sz[ch[cur][0]];
+                if (k == val[cur]){
+                    splay(cur);
+                    return res + 1;
+                }
+                res += cnt[cur], cur = ch[cur][1];
+            }
+        }
+    }
+
+    int kth(int k){
+        int cur = rt;
+        while (1){
+            if (ch[cur][0] && k <= sz[ch[cur][0]]) cur = ch[cur][0];
+            else{
+                k -= cnt[cur] + sz[ch[cur][0]];
+                if (k <= 0){
+                    splay(cur);
+                    return val[cur];
+                }
+                cur = ch[cur][1];
+            }
+        }
+    }
+
+    int pre(){
+        int cur = ch[rt][0];
+        if (!cur) return cur;
+        while (ch[cur][1]) cur = ch[cur][1];
+        splay(cur);
+        return cur;
+    }
+
+    int nxt(){
+        int cur = ch[rt][1];
+        if (!cur) return cur;
+        while (ch[cur][0]) cur = ch[cur][0];
+        splay(cur);
+        return cur;
+    }
+
+    void del(int k){
+        rk(k);
+        if (cnt[rt] > 1) {
+            cnt[rt]--;
+            maintain(rt);
+            return;
+        }
+        if (!ch[rt][0] && !ch[rt][1]){
+            clear(rt);
+            rt = 0;
+            return;
+        }
+        if (!ch[rt][0]) {
+            int cur = rt;
+            rt = ch[rt][1], fa[rt] = 0;
+            clear(cur);
+            return;
+        }
+        if (!ch[rt][1]) {
+            int cur = rt;
+            rt = ch[rt][0], fa[rt] = 0;
+            clear(cur);
+            return;
+        }
+        int cur = rt, x = pre();
+        fa[ch[cur][1]] = x;
+        ch[x][1] = ch[cur][1];
+        clear(cur);
+        maintain(rt);
+    }
+} tree;
+
+int main(){
+    int n, opt, x;
+    for (scanf("%d", &n); n; --n){
+        scanf("%d%d", &opt, &x);
+        if (opt == 1) tree.insert(x);
+        else if (opt == 2) tree.del(x);
+        else if (opt == 3) printf("%d\n", tree.rk(x));
+        else if (opt == 4) printf("%d\n", tree.kth(x));
+        else if (opt == 5) tree.insert(x), printf("%d\n", val[tree.pre()]), tree.del(x);
+        else tree.insert(x), printf("%d\n", val[tree.nxt()]), tree.del(x);
+    }
+    return 0;
+}
+\end{minted}
+
 \hypertarget{link-cut-tree}{%
-\subsection{15.Link Cut Tree}\label{link-cut-tree}}
+\subsection{17.Link Cut Tree}\label{link-cut-tree}}
 
 \hypertarget{ux65e0ux6839ux6811ux7248ux672cmakeroot}{%
 \subsubsection{(1).无根树版本(MakeRoot)}\label{ux65e0ux6839ux6811ux7248ux672cmakeroot}}
@@ -2411,8 +2725,8 @@ \subsubsection{哈希表}\label{ux54c8ux5e0cux8868}}
 cc_hash_table<int, int> mp;
 \end{minted}
 
-\hypertarget{zkwux7ebfux6bb5ux6811ux4e0dux5e26ux4feermqonlog-log-no1}{%
-\subsection{\texorpdfstring{ZKW线段树+不带修RMQ(\(O(N\log \log N)+O(1)\))}{ZKW线段树+不带修RMQ(O(N\textbackslash log \textbackslash log N)+O(1))}}\label{zkwux7ebfux6bb5ux6811ux4e0dux5e26ux4feermqonlog-log-no1}}
+\hypertarget{ux9644ux5f55zkwux7ebfux6bb5ux6811ux4e0dux5e26ux4feermqonlog-log-no1}{%
+\subsection{\texorpdfstring{附录：ZKW线段树+不带修RMQ(\(O(N\log \log N)+O(1)\))}{附录：ZKW线段树+不带修RMQ(O(N\textbackslash log \textbackslash log N)+O(1))}}\label{ux9644ux5f55zkwux7ebfux6bb5ux6811ux4e0dux5e26ux4feermqonlog-log-no1}}
 
 普通的 zkw 线段树解法分为线性建树和单次 \(O(logn)\)
 的查询，显然查询是瓶颈。