数据结构-Old Driver Tree(Chtholly Tree)

学习笔记-珂朵莉树

ODT是不知何时火起来的一种暴力数据结构，这玩意是一种基于stl的set的一种奇怪的东西，叫它珂朵莉树是因为它的暴力美学，也因为它的出处 CF896C 

话不多说，进入正题，这玩意我是看着SJR大佬的博客，在WZY和MXY大佬的答疑下弄会的。因为我是在太弱了，学这玩意之前连重载运算符和构造函数都不会用，并且set也没用过。。。

存储原理

首先定义一种结构体，

struct node
{
    int l,r;
    mutable LL v;//mutable以便随时在set里改变它的值
    node(int L, int R=-1, LL V=0):l(L), r(R), v(V) {}//构造函数，便于快速添加结构体
    bool operator<(const node& o) const//重载运算符，以左端为标准排列在set里面
    {
        return l < o.l;
    }
};

这样的一个结构体表示在数列的[l, r]之间全都是v，然后用set存储，这样可以有顺序的一段一段存储序列每一段的数值。

set <node> s;

这样子就ok了

操作（一）：分裂split

这个操作可以把一段区间咔吧一下变成两个区间，值不变，相当于对整个数列什么也没做，但是会很方便后面的操作。

#define IT set<node>::iterator
IT split(int pos)//这个操作会把区间[l, r]从pos分开成[l, pos - 1][pos, r]两部分
{
    IT it = s.lower_bound(node(pos));//因为区间按照左端排序，所以可以利用lowerbound快速找到左端点大于等于pos的第一个区间
    if (it != s.end() && it->l == pos) return it;//如果左端点正好是pos那就不用split了
    --it;//如果是大于就操作前一个区间
    int L = it->l, R = it->r;
    LL V = it->v;//存储一下区间的两端和值
    s.erase(it);//扔掉这个区间
    s.insert(node(L, pos-1, V));//添加左区间
    return s.insert(node(pos, R, V)).first;//添加右区间并返回它的迭代器，insert函数的first是所加入的区间的迭代器
}

这个函数大体思路：找到区间，特判，记录值，扔掉区间，加入区间，返回迭代器，注意pos在右区间内（划重点）

操作（二）：区间赋值ass♂ign

有了split函数，我们就可以把需要区间赋值两端点切开，把中间的区间全部扔掉，然后加入一个新区间，由于这个操作会减少set中的元素个数，所以就可以保证复杂度是对的，代码如下

void assign(int l, int r, LL val=0)
{
    IT itl = split(l),itr = split(r+1);//记录左右端
    s.erase(itl, itr);//扔掉[l, r)的所有东西
    s.insert(node(l, r, val));//把新的搞进来
}

其他操作：直接按照存储原理暴力

区间加：两端切开，切下来的所有区间暴力加

void add(int l, int r, LL val=1)
{
    IT itl = split(l),itr = split(r+1);
    for (; itl != itr; ++itl) itl->v += val;
}

区间查询第k小：切出来暴力排序

LL rank(int l, int r, int k)
{
    vector<pair<LL, int> > vp;
    IT itl = split(l),itr = split(r+1);
    vp.clear();
    for (; itl != itr; ++itl)
        vp.push_back(pair<LL,int>(itl->v, itl->r - itl->l + 1));
    sort(vp.begin(), vp.end());
    for (vector<pair<LL,int> >::iterator it=vp.begin();it!=vp.end();++it)
    {
        k -= it->second;
        if (k <= 0) return it->first;
    }
    return -1LL;
}

区间幂和：快速幂，乘以段长，期间不要忘记膜，不然就naive了

LL sum(int l, int r, int ex, int mod)
{
    IT itl = split(l),itr = split(r+1);
    LL res = 0;
    for (; itl != itr; ++itl)
        res = (res + (LL)(itl->r - itl->l + 1) * pow(itl->v, LL(ex), LL(mod))) % mod;
    return res;
}

代码实现

由于我太弱，总写炸，就直接把标程弄进来了

#include<cstdio>
#include<set>
#include<vector>
#include<utility>
#include<algorithm>
#define IT set<node>::iterator

using std::set;
using std::vector;
using std::pair;

typedef long long LL;
const int MOD7 = 1e9 + 7;
const int MOD9 = 1e9 + 9;
const int imax_n = 1e5 + 7;

LL pow(LL a, LL b, LL mod)
{
    LL res = 1;
    LL ans = a % mod;
    while (b)
    {
        if (b&1) res = res * ans % mod;
        ans = ans * ans % mod;
        b>>=1;
    }
    return res;
}

struct node
{
    int l,r;
    mutable LL v;
    node(int L, int R=-1, LL V=0):l(L), r(R), v(V) {}
    bool operator<(const node& o) const
    {
        return l < o.l;
    }
};

set<node> s;

IT split(int pos)
{
    IT it = s.lower_bound(node(pos));
    if (it != s.end() && it->l == pos) return it;
    --it;
    int L = it->l, R = it->r;
    LL V = it->v;
    s.erase(it);
    s.insert(node(L, pos-1, V));
    return s.insert(node(pos, R, V)).first;
}

void add(int l, int r, LL val=1)
{
    IT itl = split(l),itr = split(r+1);
    for (; itl != itr; ++itl) itl->v += val;
}

void assign_val(int l, int r, LL val=0)
{
    IT itl = split(l),itr = split(r+1);
    s.erase(itl, itr);
    s.insert(node(l, r, val));
}

LL rank(int l, int r, int k)
{
    vector<pair<LL, int> > vp;
    IT itl = split(l),itr = split(r+1);
    vp.clear();
    for (; itl != itr; ++itl)
        vp.push_back(pair<LL,int>(itl->v, itl->r - itl->l + 1));
    std::sort(vp.begin(), vp.end());
    for (vector<pair<LL,int> >::iterator it=vp.begin();it!=vp.end();++it)
    {
        k -= it->second;
        if (k <= 0) return it->first;
    }
    return -1LL;
}

LL sum(int l, int r, int ex, int mod)
{
    IT itl = split(l),itr = split(r+1);
    LL res = 0;
    for (; itl != itr; ++itl)
        res = (res + (LL)(itl->r - itl->l + 1) * pow(itl->v, LL(ex), LL(mod))) % mod;
    return res;
}

int n, m;
LL seed, vmax;

LL rnd()
{
    LL ret = seed;
    seed = (seed * 7 + 13) % MOD7;
    return ret;
}

LL a[imax_n];

int main()
{
    scanf("%d %d %lld %lld",&n,&m,&seed,&vmax);
    for (int i=1; i<=n; ++i)
    {
        a[i] = (rnd() % vmax) + 1;
        s.insert(node(i,i,a[i]));
    }
    s.insert(node(n+1, n+1, 0));
    int lines = 0;
    for (int i =1; i <= m; ++i)
    {
        int op = int(rnd() % 4) + 1;
        int l = int(rnd() % n) + 1;
        int r = int(rnd() % n) + 1;
        if (l > r)
            std::swap(l,r);
        int x, y;
        if (op == 3)
            x = int(rnd() % (r-l+1)) + 1;
        else
            x = int(rnd() % vmax) +1;
        if (op == 4)
            y = int(rnd() % vmax) + 1;
        if (op == 1)
            add(l, r, LL(x));
        else if (op == 2)
            assign_val(l, r, LL(x));
        else if (op == 3)
            printf("%lld\n",rank(l, r, x));
        else
            printf("%lld\n",sum(l, r, x, y));
    }
    return 0;
}