珂朵莉树及一些相关题目

比分块还要暴力、比线段树还要好写的功能萎缩而强大的数据结构。只要有类似于区间赋值的操作且数据随机，珂朵莉树就可以完成几乎所有查询。

先从一道例题说起：
CF896C
也许是珂朵莉树名字的由来？由于珂朵莉树更加珂学所以人们渐渐放弃了老司机树或者ODT的叫法
区间赋值、数据随机，所以我们就要上乱搞了。很不显然，经过若干次随机操作后，假如把数字相同的一段区间看成一个点的话，原序列只会剩下\(logn\)个点。这就启发我们，就是要把区间缩成一个点。
既然是一个点又要代表一段区间，那结构体就再合适不过了。
同时，我们把这些区间整理在一起，用一个\(set\)维护。

struct node {
    int l, r;
    mutable ll val; //由于下面区间加的操作要修改val值，所以要加mutable
    inline node(int _l, int _r = 0, ll _val = 0) : l(_l), r(_r), val(_val) {}
    inline int operator < (const node &a) const {
        return l < a.l;
    }
};
set <node> s;

珂朵莉树基本操作：

\(split\)

inline set<node>::iterator split(int x)
{
    set<node>::iterator it = s.lower_bound(node(x));
    if (it != s.end() && it->l == x) return it;
    it--;
    int l = it->l, r = it->r;
    ll val = it->val;
    s.erase(it);
    s.insert(node(l, x - 1, val));
    return s.insert(node(x, r, val)).first; //返回你插入的位置，insert的一个神仙用法
}

将\([l, r]\)的区间分成\([l, x - 1]\)和\([x, r]\)，这样\(x\)就成了一个区间的左端点，方便后续处理。

\(assign\)

inline void assign(int l, int r, int x)
{
    set<node>::iterator itr = split(r + 1), itl = split(l); //注意这个细节，正着写会RE
    s.erase(itl, itr); //删掉一段左闭右开的区间，erase的一个神仙用法
    s.insert(node(l, r, x));
}

代码复杂度堪比树状数组……把原来的全删了，再加一个回去，复杂度就是在这里变松了。
其它操作就简单粗暴了……

inline void add(int l, int r, ll x)
{
    set<node>::iterator itr = split(r + 1), itl = split(l);
    while (itl != itr) itl->val += x, itl++;
}

inline ll get_kth(int l, int r, int k)
{
    set<node>::iterator itr = split(r + 1), itl = split(l);
    vector<pair<ll, int> > v;
    while (itl != itr) v.push_back(make_pair(itl->val, itl->r - itl->l + 1)), itl++;
    sort(v.begin(), v.end());
    for (vector<pair<ll, int> >::iterator it = v.begin(); it != v.end(); it++) {
        if (k <= it->second) return it->first;
        k -= it->second;
    }
    return 0;
}

inline int ksm(int a, int n, int mod)
{
    int b = 1;
    while (n) {
        if (n & 1) b = 1ll * a * b % mod;
        a = 1ll * a * a % mod;
        n >>= 1;
    }
    return b;
}

inline int sum(int l, int r, int x, int mod)
{
    set<node>::iterator itr = split(r + 1), itl = split(l);
    int res = 0;
    while (itl != itr) res = (res + 1ll * (itl->r - itl->l + 1) * ksm(itl->val % mod, x, mod)) % mod, itl++;
    return res;
}

同样注意\(itr\)要先写就好了。

然后是一些板题（都是线段树题但信奉珂学的话就要用珂朵莉树做）
P2572
一个字，板。
CF915E
注意\(assign\)的同时要处理好答案，如果每次都暴力扫整个\(set\)的话会\(T\)。
P2486
珂朵莉上树
不，是珂朵莉树上树。
查询比较麻烦，要注意有序树剖的各种细节问题，开两个\(vector\)，一个存\(x\)到\(lca\)的，另一个存\(y\)到\(lca\)的，然后把第二个\(vector\)倒着接到第一个上面，最后暴力统计答案。
由于在树上依然会经常有很长的链被覆盖成一种颜色，维护一条重链的\(set\)的\(size\)可能会非常小，所以我猜想复杂度会比\(nlog^2n\)要低。
贴下代码吧：

#include <iostream>
#include <cstring>
#include <cstdio>
#include <vector>
#include <set>

const int maxn = 1e5 + 7;

using namespace std;

int a[maxn];
int to[maxn << 1];
int nex[maxn << 1];
int last[maxn], k;
int fa[maxn];
int son[maxn];
int sz[maxn];
int dep[maxn];
int top[maxn];
int dfn[maxn], id;
struct node {
    int l, r, val;
    inline node(int _l, int _r = 0, int _val = 0) : l(_l), r(_r), val(_val) {}
    inline int operator < (const node &a) const {
        return l < a.l;
    }
};
set <node> s;
vector <node> v[2];

inline int read()
{
    int X = 0; char ch = getchar();
    while (ch < '0' || ch > '9') ch = getchar();
    while (ch >= '0' && ch <= '9') X = X * 10 + ch - '0', ch = getchar();
    return X;
}

inline void add_edge(int x, int y)
{
    to[++k] = y; nex[k] = last[x]; last[x] = k;
}

inline set<node>::iterator split(int x)
{
    set<node>::iterator it = s.lower_bound(node(x));
    if (it != s.end() && it->l == x) return it;
    it--;
    int l = it->l, r = it->r, val = it->val;
    s.erase(it);
    s.insert(node(l, x - 1, val));
    return s.insert(node(x, r, val)).first;
}

inline void assign(int l, int r, int val)
{
    set<node>::iterator itr = split(r + 1), itl = split(l);
    s.erase(itl, itr);
    s.insert(node(l, r, val));
}

inline void get(int l, int r, int type)
{
    set<node>::iterator itr = split(r + 1), itl = split(l);
    itr--;
    while (1) {
        v[type].push_back(*itr);
        if (itl == itr) break;
        itr--;
    }
}

inline 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;
}

inline void upchain(int x, int y, int z)
{
    while (top[x] != top[y]) {
        if (dep[top[x]] < dep[top[y]]) swap(x, y);
        assign(dfn[top[x]], dfn[x], z);
        x = fa[top[x]];
    }
    if (dep[x] > dep[y]) swap(x, y);
    assign(dfn[x], dfn[y], z);
}

inline int sum(int x, int y)
{
    v[0].clear();
    v[1].clear();
    int g = lca(x, y);
    while (top[x] != top[g]) {
        get(dfn[top[x]], dfn[x], 0);
        x = fa[top[x]];
    }
    get(dfn[g], dfn[x], 0);
    while (top[y] != top[g]) {
        get(dfn[top[y]], dfn[y], 1);
        y = fa[top[y]];
    }
    get(dfn[g], dfn[y], 1);
    for (vector<node>::iterator it = v[1].end() - 1;; it--) {
        v[0].push_back(*it);
        if (it == v[1].begin()) break;
    }
    int pre = 0, ans = 0;
    for (vector<node>::iterator it = v[0].begin(); it != v[0].end(); it++)
        if (it->val != pre) pre = it->val, ans++;
    return ans;
}

void dfs1(int x, int f)
{
    sz[x] = 1;
    fa[x] = f;
    dep[x] = dep[f] + 1;
    for (int i = last[x]; i; i = nex[i]) {
        int y = to[i];
        if (y == f) continue;
        dfs1(y, x);
        sz[x] += sz[y];
        if (sz[y] > sz[son[x]]) son[x] = y;
    }
}

void dfs2(int x, int f)
{
    top[x] = f;
    dfn[x] = ++id;
    s.insert(node(id, id, a[x]));
    if (!son[x]) return;
    dfs2(son[x], f);
    for (int i = last[x]; i; i = nex[i])
        if (to[i] != fa[x] && to[i] != son[x]) dfs2(to[i], to[i]);
}

int main(void)
{
    int n = read(), m = read();
    for (int i = 1; i <= n; i++) a[i] = read();
    for (int i = 1; i < n; i++) {
        int x = read(), y = read();
        add_edge(x, y);
        add_edge(y, x);
    }
    dfs1(1, 0);
    dfs2(1, 1);
    while (m--) {
        char opt;
        scanf(" %c", &opt);
        int x = read(), y = read();
        if (opt == 'C') upchain(x, y, read());
        else printf("%d\n", sum(x, y));
    }
    
    return 0;
}