ODT珂朵莉树

其他 2020-02-27 22:17:27 阅读次数: 0

关于ODT，据说是毒瘤lxl发明的，然后毒瘤鱼鱼因为我用ODT误导人D了我一回……

这是一种基于 \(set\) 的暴力数据结构。

在使用时请注意，没看见这2东西千万别用……

1.保证数据随机

2.有区间推平操作。

这里解释一下区间推平：就是把区间 [l,r] 的值都变为val。

然后就是各种暴力：区间翻转、区间求和、区间k次幂和……

板子

先看看它能干什么再往下看qwq（当然ODT的操作远不止这些）。

首先先讲一下基础：set的定义。对于每个节点用 \((l,r,val)\) 描述（所以为什么要区间推平，否则节点数太多）

然后搞个结构体。

struct node {
    int l,r;
    mutable int val;//mutable一定要加，后面会修改set中的值，不加就修改不了。
    node(int L,int R=-1,int V=0):l(L),r(R),val(V){}//看不懂不要紧，后面用上的时候就懂了
    bool operator < (const node &rhs)const{return l<rhs.l;}//按照左端点排序
};
set<node>s;

然后是最重要的函数 \(Split(int pos)\) 。它的作用是找到包含pos的区间 [l,r] ，然后把它分裂成 [l,pos-1], [pos,r] 并且返回pos处的指针。后面操作的时候，往往需要对一段区间进行操作，我们把这段区间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 ll=it->l,rr=it->r,v=it->val;
    s.erase(it);
    s.insert(node(ll,pos-1,v));
    return s.insert(node(pos,rr,v)).first;
}

注意，Split的时候按端点从大到小Split，否则会玄学RE 众所周知，set，尤其是指针，可玄学了

接着是 \(Assign\) ，代码超级短，时间复杂度很低，ODT就是靠这个才能保证时间复杂度的。

void Assign(int l,int r,int val) {
    IT itr=Split(r+1),itl=Split(l);//于是区间 [l,r] 对应的指针就是 [itl,itr]
    s.erase(itl,itr);
    s.insert(node(l,r,val));
}

其余就是各种暴力，还是看上面的题。

1.区间修改。

不要看到这种就想线段树和树状数组，这里在讲ODT呢

ODT设计函数的时候记住一句话：除了Split和Assign，全部暴力

看看代码就懂了qwq

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

2.区间推平。上面讲过了，略。

3.区间第k小

也不要想着主席树什么的，这里在讲ODT！

int kth(int l,int r,int k)
{
    vector<pair<int,int> >v;
    it itr=split(r+1),itl=split(l); 
    for(;itl!=itr;itl++)v.push_back(pair<int,int>(itl->val,itl->rr-itl->ll+1));
    sort(v.begin(),v.end());//按照权值排序
    for(vector<pair<int,int> >::iterator iter=v.begin();iter!=v.end();iter++)
    {
        k-=iter->second;//不断减，直到达到k。其实可以前缀和+二分做到 O(n)，但是不需要
        if(k<=0)return iter->first;
    }
    return -1;
}

相信各位巨佬看完就懂了

4.区间幂次方和。稍微有点复杂。不过这个快速幂的优化一定得加，不然会TLE。

int ksm(int n,int k,int p)
{
    int base=n%p,ans=1;
    while(k)
    {
        if(k&1)ans=ans*base%p;
        k>>=1;
        base=base*base%p;
    }
    return ans%p;
}

int querypow(int l,int r,int k,int mod)
{
    it itr=split(r+1),itl=split(l);
    int res=0;
    for(;itl!=itr;itl++)
        res=(res+ksm(itl->val,k,mod)*((itl->rr-itl->ll+1)%mod)%mod)%mod;
    return res;
}

不要忘记乘长度就好了。

完整代码：

#include <bits/stdc++.h>
using namespace std;
#define int long long
const int MAXN=100005;
int n,m,seed,vmax,a[MAXN];
int rnd()
{
    int ret=seed;
    seed=(seed*7+13)%1000000007;
    return ret;
}
int ksm(int n,int k,int p)
{
    int base=n%p,ans=1;
    while(k)
    {
        if(k&1)ans=ans*base%p;
        k>>=1;
        base=base*base%p;
    }
    return ans%p;
}
struct node{
    int ll,rr;
    mutable int val;
    node(int L,int R=-1,int V=0):ll(L),rr(R),val(V){}
    bool operator < (const node & rhs)const{return ll<rhs.ll;}
};
set<node>s;
#define it set<node>::iterator
it split(int pos)
{
    it iter=s.lower_bound(node(pos));
    if(iter!=s.end()&&iter->ll==pos)return iter;
    --iter;
    int l=iter->ll,r=iter->rr,v=iter->val;
    s.erase(iter);
    s.insert(node(l,pos-1,v));
    return s.insert(node(pos,r,v)).first;
}
void assign(int l,int r,int v)
{
    it itr=split(r+1),itl=split(l);
    s.erase(itl,itr);
    s.insert(node(l,r,v));
}
int kth(int l,int r,int k)
{
    vector<pair<int,int> >v;
    it itr=split(r+1),itl=split(l); 
    for(;itl!=itr;itl++)v.push_back(pair<int,int>(itl->val,itl->rr-itl->ll+1));
    sort(v.begin(),v.end());
    for(vector<pair<int,int> >::iterator iter=v.begin();iter!=v.end();iter++)
    {
        k-=iter->second;
        if(k<=0)return iter->first;
    }
    return -1;
}
void add(int l,int r,int k)
{
    it itr=split(r+1),itl=split(l);
    for(;itl!=itr;itl++) 
    itl->val+=k;
}
int querypow(int l,int r,int k,int mod)
{
    it itr=split(r+1),itl=split(l);
    int res=0;
    for(;itl!=itr;itl++)
        res=(res+ksm(itl->val,k,mod)*((itl->rr-itl->ll+1)%mod)%mod)%mod;
    return res;
}

signed main() {
    scanf("%lld%lld%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]));
    }
    for(int i=1;i<=m;i++)
    {
        int opt=(rnd()%4)+1;
        int l=(rnd()%n)+1;
        int r=(rnd()%n)+1;
        if(l>r)swap(l,r);
        int x,y;
        if(opt==3)x=(rnd()%(r-l+1))+1;
        else x=(rnd()%vmax)+1;
        if(opt==4)y=(rnd()%vmax)+1;
        if(opt==1)add(l,r,x);
        if(opt==2)assign(l,r,x);
        if(opt==3)printf("%lld\n",kth(l,r,x));
        if(opt==4)printf("%lld\n",querypow(l,r,x,y));
    }
    return 0;
}

然后是第2道例题：P5350 序列

看看一堆操作，使人一下想到了ODT（发现毒瘤鱼鱼的平衡树是第一篇题解……）

1.区间求和，上面都有，略。

2.区间推平，上面都有，略。

3.区间加法，上面都有，略。

4.区间复制。上面没有，qwq

int a[N],b[N],c[N],tot;
void Copy(int l1,int r1,int l2,int r2) {
    IT itr=Split(r1+1),itl=Split(l1);
    for(tot=0;itl!=itr;++itl)
        a[++tot]=l2+itl->l-l1,b[tot]=l2+itl->r-l1,c[tot]=itl->val;
    for(int i=1;i<=tot;++i)
        Assign(a[i],b[i],c[i]);
}

关于我为什么拿了3个数组存：set的指针尤其玄学，还是不要对指针进行操作了，而且代码也很短。

5.区间交换。

void Swap(int l1,int r1,int l2,int r2) {
    Copy(l1,r1,n+1,n+r1-l1+1);
    Copy(l2,r2,l1,r1);
    Copy(n+1,n+r1-l1+1,l2,r2);
}

在这个序列后加一个长为n的空序列，充分发挥已经写过的函数的作用，很方便。

6.区间翻转。

void Reverse(int l,int r) {
    IT itr=Split(r+1),itl=Split(l);
    vector<node>vec;
    for(IT it=itl;it!=itr;++it)
        vec.push_back(node(it->l,it->r,it->val));
    s.erase(itl,itr);
    int t=l;
    for(int i=vec.size()-1;i>=0;--i)
        s.insert(node(t,t+vec[i].r-vec[i].l,vec[i].val)),t+=vec[i].r-vec[i].l+1;
}

看看代码应该挺好懂……

7.关于输出（Print）。由于节点代表的是区间，所以可以这么写。

void Print(){
    IT it=s.begin();
    int print=0;
    while(print<n) {
        for(int i=it->l;i<=it->r;++i)
        {
            printf("%lld ",it->val);
            ++print;
            if(print==n)return (void)puts("");
        }
        ++it;
    }
}

然后整合起来：千万记得开O2！ 调了1h结果发现是O2的问题，气死我了

#include<bits/stdc++.h>
using namespace std;
#define int long long
const int mod=1000000007;
const int N=300005;
int n,m;
struct node {
    int l,r;
    mutable int val;
    node(int L,int R=-1,int V=0):l(L),r(R),val(V){}
    bool operator < (const node &rhs)const{return l<rhs.l;}
};
set<node>s;
#define IT set<node>::iterator
void Print(){
    IT it=s.begin();
    int print=0;
    while(print<n) {
        for(int i=it->l;i<=it->r;++i)
        {
            printf("%lld ",it->val);
            ++print;
            if(print==n)return (void)puts("");
        }
        ++it;
    }
}
IT Split(int pos){
    IT it=s.lower_bound(node(pos));
    if(it!=s.end()&&it->l==pos)return it;
    --it;
    int ll=it->l,rr=it->r,v=it->val;
    s.erase(it);
    s.insert(node(ll,pos-1,v));
    return s.insert(node(pos,rr,v)).first;
}
int Sum(int l,int r){
    int res=0;
    IT itr=Split(r+1),itl=Split(l);
    for(;itl!=itr;++itl)
        res=(res+(itl->r-itl->l+1)*itl->val)%mod;
    return (int)res;
}
void Assign(int l,int r,int val) {
    IT itr=Split(r+1),itl=Split(l);
    s.erase(itl,itr);
    s.insert(node(l,r,val));
}
void Add(int l,int r,int val) {
    IT itr=Split(r+1),itl=Split(l);
    for(;itl!=itr;++itl)
        itl->val=(itl->val+val)%mod;
}
int a[N],b[N],c[N],tot;
void Copy(int l1,int r1,int l2,int r2) {
    IT itr=Split(r1+1),itl=Split(l1);
    for(tot=0;itl!=itr;++itl)
        a[++tot]=l2+itl->l-l1,b[tot]=l2+itl->r-l1,c[tot]=itl->val;
    for(int i=1;i<=tot;++i)
        Assign(a[i],b[i],c[i]);
}
void Swap(int l1,int r1,int l2,int r2) {
    Copy(l1,r1,n+1,n+r1-l1+1);
    Copy(l2,r2,l1,r1);
    Copy(n+1,n+r1-l1+1,l2,r2);
}
void Reverse(int l,int r) {
    IT itr=Split(r+1),itl=Split(l);
    vector<node>vec;
    for(IT it=itl;it!=itr;++it)
        vec.push_back(node(it->l,it->r,it->val));
    s.erase(itl,itr);
    int t=l;
    for(int i=vec.size()-1;i>=0;--i)
        s.insert(node(t,t+vec[i].r-vec[i].l,vec[i].val)),t+=vec[i].r-vec[i].l+1;
}
signed main() {
    scanf("%lld%lld",&n,&m);
    for(int i=1,x;i<=n;++i)
        scanf("%d",&x),s.insert(node(i,i,x));
    s.insert(node(n+1,n+n+5,0));
    while(m--) {
        int opt;
        scanf("%lld",&opt);
        if(opt==1) {
            int l,r;
            scanf("%lld%lld",&l,&r);
            printf("%d\n",Sum(l,r));
        }
        if(opt==2) {
            int l,r,val;
            scanf("%lld%lld%lld",&l,&r,&val);
            Assign(l,r,val);
        }
        if(opt==3) {
            int l,r,val;
            scanf("%lld%lld%lld",&l,&r,&val);
            Add(l,r,val);
        }
        if(opt==4) {
            int l1,r1,l2,r2;
            scanf("%lld%lld%lld%lld",&l1,&r1,&l2,&r2);
            Copy(l1,r1,l2,r2);
            }
        if(opt==5) {
            int l1,r1,l2,r2;
            scanf("%lld%lld%lld%lld",&l1,&r1,&l2,&r2);
            Swap(l1,r1,l2,r2);
        }
        if(opt==6) {
            int l,r;
            scanf("%lld%lld",&l,&r);
            Reverse(l,r);
        }
    }
    Print();
    return 0;
}

反正ODT是个玄学的东西，set的指针要尤其小心。操作的时候尽量避免指针。但是思路简单，时间复杂度在数据随机且有区间推平的时候很靠谱。在洛谷上交ODT的时候千万记得开O2，否则很容易TLE。

猜你喜欢

转载自www.cnblogs.com/zzctommy/p/12374599.html
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
周排行
让自己的头脑极度开放
CentOS 6.5(x64) 和Redhat6.5操作系误删libc
高可用注册中心
【日记】12.28/【题解】AtCoder AGC041
XML（5）_XML 约束_DTD
Java集合Map（四）
树梅派安装桌面环境教程
pipenv 的 使用和安装
小程序白屏问题和内存研究
C语言简单选择排序
每日归档
更多
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022