珂朵莉树(odt老司机树)

本文深入探讨了珂朵莉树(OldDriverTree)这一基于std::set的数据结构,详细介绍了其核心操作split和assign,以及如何实现区间更新和平坦化。通过具体代码示例,展示了珂朵莉树在解决区间操作问题上的应用。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

传送门

题意:对于一段区间一共有四种操作:

题解:珂朵莉树板题

珂朵莉树,又称Old Driver Tree(ODT)。是一种基于std::set的暴力数据结构。

关键操作:推平一段区间,使一整段区间内的东西变得一样。保证数据随机。

这道题里,这样定义珂朵莉树的节点:

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

 这样的一个节点表示[l,r]内的所有数都是v。需要注意的是mutable,意为易变的,不定的。它对v的修饰,使得可以在add操作中修改v的值。没有它的修饰会在add函数里导致CE。

核心操作:split

#define IT set<node>::iterator
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;
}

 最后一句插入后半段,返回后半段的迭代器。这里利用了pair<iterator,bool> insert (const value_type& val)的返回值。

推平操作:assign

void assign(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));
}

附上代码:

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

 

莉树Odt Tree),也被称为 Old Driver TreeODT,是一种基于分治思想设计的数据结构,主要用于解决区间修改和查询问题。它通过将整个序列划分为若干连续子段来优化操作效率,在某些情况下可以达到接近线性的时间复杂度。 ### 莉树的核心概念 莉树本质上是一个动态划分的链表或者向量,其中每个节点表示一段连续相同的数值区间。当执行区间更新时,如果某段区间的值全部相同,则可以直接整体替换;否则将其进一步拆分成更小的部分处理[^1]。 这种数据结构特别适合于那些频繁涉及大范围赋值以及单点/区间查询的操作场景下使用。 ### 实现细节 下面给出了一种简单的 C++ 实现方式: ```cpp #include <bits/stdc++.h> using namespace std; struct node { int l, r; mutable long long v; // 可变字段用于懒惰标记等扩展功能 bool operator<(const node& oth) const { return r < oth.l; } }; set<node> s; // 定义辅助函数 split 来分割指定位置 pos 所属的那个区间 auto split(int pos){ auto it = s.upper_bound((node){pos,0}); --it; if(it->l == pos) return it; int L=it->l,R=it->r,v=it->v; s.erase(it); s.insert(node{L,pos-1,v}); return s.insert(node{pos,R,v}).first; } void assign(int l,int r,long long val){ auto rit=split(r+1),lit=split(l); s.erase(lit,rit); s.insert(node{l,r,val}); } long long query_sum(int l,int r){ long long res=0; for(auto it=split(l);it!=split(r+1);++it) res += (long long)(it->r-it->l+1)*(it->v); return res; } ``` 上述代码片段定义了一个 `node` 结构体用来存储每一段的信息,并利用标准库中的 `std::set` 维护这些节点有序排列的状态。为了方便后续操作还实现了两个重要方法——`split()` 和实际业务逻辑如批量赋值(`assign`)及求和(`query_sum`)等功能模块[^2]。 需要注意的是,虽然理论上该算法表现良好,但在极端测试用例面前仍可能存在性能瓶颈,因此在竞赛编程或其他高性能需求环境中应用前需谨慎评估其适用性和局限性。 问题
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值