学习笔记--线段树合并与分裂

最新推荐文章于 2022-09-13 21:02:10 发布
最新推荐文章于 2022-09-13 21:02:10 发布
阅读量907 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/Rye-Catcher/p/9763643.html
版权

前言

集训时侯讲了一道线段树神题,看题解时FA现需要一个叫"线段树合并"的前置技能点,于是就补了这个坑顺便了解一下线段树的分裂

需要前置技能点:

  • 线段树

    • 动态开点权值线段树

参考链接

https://wenku.baidu.com/view/88f4e134e518964bcf847c95.html

https://www.cnblogs.com/Mychael/p/8665589.html

https://www.cnblogs.com/zzqsblog/p/6181434.html

分析

这里的线段树合并是针对动态开点的权值线段树而言的,线段树合并与分裂可以快速合并一些信息或分裂区间,完成一些查询区间第\(k\)大等奇奇怪怪的操作

合并Merge

代码

int merge(int x,int y){
  /*合并x和y*/
        if(!x)return y;
        if(!y)return x;
        int t=new_node();
        sum[t]=sum[x]+sum[y];
        ls[t]=merge(ls[x],ls[y]);
        rs[t]=merge(rs[x],rs[y]);
        return t;
}

时间复杂度博客中都说是\(O(N \log N)\),不过证明都感觉不太理解

分裂Split

代码

void split(int &now,int &po,int l,int r,int k){
/*将now中前k个分裂到po中去*/
    if(!now)return ;
    if(!po)po=new_node();
    if(l==r){
        sum[now]-=k,sum[po]+=k;
        return ;
    }
    int tt=sum[ls[now]],mid=(l+r)>>1;
    if(k<tt)split(ls[now],ls[po],l,mid,k);
    else ls[po]=ls[now],ls[now]=0;
    if(tt<k){
        split(rs[now],rs[po],mid+1,r,k-tt);
    }
    pushup(now),pushup(po);
    return ;
}

时间复杂度看上去也像\(O(N \log N)\)

数组大小

这个不怎么会算,因为这个RE/MLE了好多发,考场上建议拿极限数据跑一跑看看会不会RE

例题

luogu3605竞升者计数

https://www.luogu.org/problemnew/show/P3605

分析

不错的上手题,像可并堆一样自底向上合并同时不断统计答案

代码
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <cctype>
#include <iostream>
#include <queue>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/hash_policy.hpp>
#define ll long long 
#define ri register int 
using std::min;
using std::max;
using namespace __gnu_pbds;
template <class T>inline void read(T &x){
    x=0;int ne=0;char c;
    while(!isdigit(c=getchar()))ne=c=='-';
    x=c-48;
    while(isdigit(c=getchar()))x=(x<<3)+(x<<1)+c-48;
    x=ne?-x:x;return ;
}
const int maxn=200005;
const int inf=0x7fffffff;
struct Edge{
    int ne,to;
}edge[maxn];
int h[maxn],num_edge=1;
inline void add_edge(int f,int to){
    edge[++num_edge].ne=h[f];
    edge[num_edge].to=to;
    h[f]=num_edge;
}
gp_hash_table <ll,int> g;
int rt[maxn],sum[maxn<<2],f[maxn],tot=0;
int ls[maxn],rs[maxn];
int n,v[maxn],cnt=0;
int L,R,t;
int ans=0,anss[maxn];
void query(int now,int l,int r){
    if(L<=l&&r<=R){
        ans+=sum[now];return ;
    }
    int mid=(l+r)>>1;
    if(L<=mid)query(ls[now],l,mid);
    if(mid<R) query(rs[now],mid+1,r);
    return ;

}
void update(int &now,int l,int r){
    if(!now)now=++cnt;
    sum[now]++;
    if(l==r)return ;
    int mid=(l+r)>>1;
    if(t<=mid)update(ls[now],l,mid);
    else update(rs[now],mid+1,r);
    return ;
}
int merge(int x,int y){
    if(!x)return y;
    if(!y)return x;
    int t=++cnt;
    sum[t]=sum[x]+sum[y];
    ls[t]=merge(ls[x],ls[y]);
    rs[t]=merge(rs[x],rs[y]);
    return t;
}
void dfs(int now){
    for(ri i=h[now];i;i=edge[i].ne){
        dfs(edge[i].to);
        merge(rt[now],rt[edge[i].to]);
    }
    L=v[now]+1,R=tot;
    ans=0;
    query(1,1,n);
    anss[now]=ans;
    t=v[now];
    update(rt[now],1,tot);
}
int main(){
    int x,y;ll z;
    read(n);
    for(ri i=1;i<=n;i++){
        read(z);
        if(!g[z]){
            g[z]=++tot;
            f[tot]=z;
        }
        v[i]=g[z];
    }
    for(ri i=2;i<=n;i++){
        read(i);
        add_edge(i,x);
    }
    dfs(1);
    for(ri i=1;i<=n;i++)printf("%d\n",anss[i]);
    return 0;
}
luogu3521 Tree Rotations

https://www.luogu.org/problemnew/show/P3521

分析

一个显然的性质,DFS序中子树是一段连续区间,对于节点\(x\)的儿子节点\(son[x][i]\),交换它们之间的顺序对除\(x\)子树外的逆序对顺序不会造成任何影响,所以我们只考虑贪心地交换儿子节点使产生的逆序对最少就好了

但是考虑怎么在分别计算交换与不交换两棵线段树\(Tx,Ty\)各自产生的贡献,我们分治地考虑这个问题,假设一开始\(Tx\)在左边,那么不交换的话答案就是\(Tx,Ty\)中各自逆序对个数加上\(\sum_i^{size[Tx]} \sum_j^{size[Ty]}[a[i]>a[j]]\)

前面的答案我们可以在自下而上合并中统计出来,但是考虑右边那个怎么算

iYut2D.md.png

这里还是不交换的情况,首先C区间肯定是会对A区间产生贡献(显然,这里的区间是值域区间),但是可能会忽略掉一些\(Tx\)在A区间中的数比\(Ty\)对应区间还要小的情况,所以我们还要加上\(D\)对\(B\)的贡献,以此类推,当然左区间也要递归

考虑交换的情况类似,反过来就好,不多说

然后这些可以在合并时计算出来

代码
// luogu-judger-enable-o2
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <cctype>
#include <queue>
#include <vector>
#define SIZE 1926081
#define ll long long 
#define ri register int 
using std::min;
using std::max;
inline char gc(){
    static char buf[SIZE],*p1=buf,*p2=buf;
    return p1==p2&&(p2=(p1=buf)+fread(buf,1,SIZE,stdin),p1==p2)?EOF:*p1++;
}
#ifdef RyeCatcher
    #define gc getchar
#endif
template <class T>inline void read(T &x){
    x=0;int ne=0;char c;
    while(!isdigit(c=gc()))ne=c=='-';x=c-48;
    while(isdigit(c=gc()))x=(x<<3)+(x<<1)+c-48;x=ne?-x:x;return ;
}
const int N=100005;
const int maxn=2000005;
const int inf=0x7fffffff;
int sum[maxn<<2],ls[maxn<<2],rs[maxn<<2];
int son[N<<2][2],ss=0;
int n,rot,rt[N<<2],tot=0;
ll val[N<<2];
ll cnt1,cnt2,ans=0;
int init(){
    int x;
    read(x);
    ss++;
    if(!x){
        x=ss;
        son[x][0]=init();
        son[x][1]=init();
    }
    else{
        val[ss]=x;
        x=ss;
    }
    return x;
}
int merge(int x,int y){
    if(!x)return y;
    if(!y)return x;
    int t=++tot;
    sum[t]=sum[x]+sum[y];
    cnt1+=1ll*sum[ls[x]]*sum[rs[y]];
    cnt2+=1ll*sum[rs[x]]*sum[ls[y]];
    ls[t]=merge(ls[x],ls[y]);
    rs[t]=merge(rs[x],rs[y]);
    return t;
}
int t;
void update(int &now,int l,int r){
    if(!now)now=++tot;
    sum[now]++;
    if(l==r)return ;
    int mid=(l+r)>>1;
    if(t<=mid)update(ls[now],l,mid);
    else update(rs[now],mid+1,r);
    return ;
}
void dfs(int now){
    if(val[now]){
        t=val[now];
        update(rt[now],1,n);
        return ;
    }
    dfs(son[now][0]);
    dfs(son[now][1]);
    cnt1=cnt2=0;
    rt[now]=merge(rt[son[now][0]],rt[son[now][1]]);
    ans+=min(cnt1,cnt2);
    return ;
}
int main(){
    read(n);
    rot=init();
    dfs(rot);
    printf("%lld\n",ans);
    return 0;
}
luogu2824排序

https://www.luogu.org/problemnew/show/P2824

分析

一种思路就是直接二分,然后线段树操作一波,但是这是离线的

线段树合并与分裂就可以在线地做这道题

我们一开始把所有单个元素看成一颗权值线段树,然后1操作和2操作不断合并线段树即可

但是有一些要注意的地方,就是左右端点可能恰在某些线段树表示区间的中间,我们可以通过\(set\)查找出这种区间,这时候要分裂出来才能合并,同时降序和升序在分裂时需要分类讨论,其实降序的话直接把那段反过来算就好了,但还是比较烦人

同时还学到了一个像是垃圾回收节约内存的操作:

用一个栈或队列记录可以用的空节点,但感觉效果不是很显著

代码
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <cctype>
#include <iostream>
#include <queue>
#include <vector>
#include <set>
#define ll long long 
#define ull unsigned long long 
#define ri register int 
#define pb push_back;
#define SIZE 1926081
inline char gc(){
    static char buf[SIZE],*p1=buf,*p2=buf;
    return p1==p2&&(p2=(p1=buf)+fread(buf,1,SIZE,stdin),p1==p2)?EOF:*p1++;
}
template <class T>inline void read(T &x){
    x=0;int ne=0;char c;
    while((c=getchar())>'9'||c<'0')ne=c=='-';x=c-48;
    while((c=getchar())>='0'&&c<='9')x=(x<<3)+(x<<1)+c-48;x=ne?-x:x;return ;
}
using std::min;
using std::set;
using std::lower_bound;
const int maxn=200005;
const int N=2000005;
const int inf=0x7fffffff;
int n,m;
int sum[N<<2],ls[N<<2],rs[N<<2];
/*trash recycle*/
int st[N<<2],top=0;
inline void del(int x){st[++top]=x;}
inline int get_node(){int x=st[top];top--;sum[x]=ls[x]=rs[x]=0;return x;}
/*segment & set*/
struct Seg{
    int l,r,rt,ty;//ty==0 increasing  ty==1 decreasing
    Seg(){l=r=rt=ty=0;}
    Seg(int _l,int _r,int _rt,int _ty){l=_l,r=_r,rt=_rt,ty=_ty;}
    bool operator <(const Seg &b)const{
        return r==b.r?l<b.l:r<b.r;
    }
};
set<Seg>se;
/*Segment Tree*/
int pos;
inline void pushup(int now){
    sum[now]=sum[ls[now]]+sum[rs[now]];return ;
}
/*merge x and y to t*/
int merge(int x,int y){
    if(!x)return y;
    if(!y)return x;
    int t=get_node();
    sum[t]=sum[x]+sum[y];
    ls[t]=merge(ls[x],ls[y]);
    rs[t]=merge(rs[x],rs[y]);
    del(x),del(y);
    return t;
}
/*split now and put them to po*/
void split(int &now,int &po,int l,int r,int k){
    if(!now)return ;
    if(!po)po=get_node();
    if(l==r){
        sum[now]-=k,sum[po]+=k;
        return ;
    }
    //printf("~~%d %d %d %d~~\n",now,po,l,r);
    int tt=sum[ls[now]],mid=(l+r)>>1;
    if(k<tt)split(ls[now],ls[po],l,mid,k);
    else ls[po]=ls[now],ls[now]=0;
    if(tt<k){
        split(rs[now],rs[po],mid+1,r,k-tt);
    }
    pushup(now),pushup(po);
    return ;
}
/*update*/
void update(int &now,int l,int r){
    if(!now)now=get_node();
    sum[now]++;
    if(l==r)return ;
    int mid=(l+r)>>1;
    if(pos<=mid)update(ls[now],l,mid);
    else update(rs[now],mid+1,r);
    return ;
}
/*query pos_th in an increasing sequence*/
int query(int now,int l,int r){
    if(l==r){
        return l;
    }
    int mid=(l+r)>>1,tt=sum[ls[now]];
    //printf("--%d %d %d %d %d--\n",now,l,r,tt,pos);
    if(tt>=pos)return query(ls[now],l,mid);
    pos-=tt;
    return query(rs[now],mid+1,r);
}
Seg tmp=Seg(0,0,0,0);
set<Seg>::iterator it,pit;
inline int solve(int op,int l,int r){
    int x;
    tmp=Seg(0,l,0,0);
    it=se.lower_bound(tmp);
    tmp=*it;x=0;//printf("%d %d\n",tmp.l,tmp.r);
    if(tmp.l!=l){
        se.erase(it);
        if(tmp.ty==0){
            pos=l-tmp.l;
            split(tmp.rt,x,1,n,pos);
            se.insert(Seg(tmp.l,l-1,x,0));
            se.insert(Seg(l,tmp.r,tmp.rt,0));
        }
        else{
            pos=tmp.r-l+1;
            split(tmp.rt,x,1,n,pos);
            se.insert(Seg(tmp.l,l-1,tmp.rt,1));
            se.insert(Seg(l,tmp.r,x,1));
        }
    }
    //puts("sss");
    tmp=Seg(0,r,0,0);
    it=se.lower_bound(tmp);
    tmp=*it,x=0;//printf("%d %d\n",tmp.l,tmp.r);
    if(tmp.r!=r){
        se.erase(it);
        if(tmp.ty==0){
            pos=r-tmp.l+1;
            split(tmp.rt,x,1,n,pos);
            se.insert(Seg(tmp.l,r,x,0));
            se.insert(Seg(r+1,tmp.r,tmp.rt,0));
        }
        else{
            pos=tmp.r-r;
            split(tmp.rt,x,1,n,pos);
            se.insert(Seg(tmp.l,r,tmp.rt,1));
            se.insert(Seg(r+1,tmp.r,x,1));
        }   
    }
    x=0,it=se.lower_bound(Seg(0,l,0,0));
    while(it!=se.end()&&(*it).r<=r){
        tmp=*it;
        x=merge(x,tmp.rt);
        se.erase(it);
        it=se.lower_bound(Seg(0,l,0,0));
    }
    se.insert(Seg(l,r,x,op));
    //printf("**%d**\n",x);
    return x;    
}
int main(){
    int x,y;
    int op,l,r;
    for(ri i=N;i>=0;i--)st[++top]=i;
    read(n),read(m);
    for(ri i=1;i<=n;i++){
        read(x);//printf("%d\n",x);
        y=get_node();
        pos=x;
        update(y,1,n);
        se.insert(Seg(i,i,y,0));
    }
    //printf("()()(%d)()()\n",st[top]);
    while(m--){
        read(op),read(l),read(r);
        solve(op,l,r);
        //printf("()()(%d)()()\n",st[top]);
    }
    read(x);
    y=solve(0,x,x);
    pos=1;
    printf("%d\n",query(y,1,n));
    return 0;
}
luogu4197Peaks

https://www.luogu.org/problemnew/show/P4197

分析

在线做法Kruskal重构树

离线有种简单易懂的线段树合并解法,首先将边和询问的困难度都各自从小到大排序一遍,然后不断加边,直至边的困难度超过当前询问就换到下一个询问

然而不知道为何疯狂RE，太菜了

UPDATE: 感谢Ebola巨佬,指出了merge那里的错误就不会RE了,同时对拍时发现犯了个SB的错误,我直接输出了离散化后的编号...终于A了

注意这时候一颗线段树是表示一个联通块,合并时是要合并所在联通块所表示的根节点,使用并查集完成

代码
/*
  Code By RyeCatcher
  2018.10.9
*/
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <cctype>
#include <vector>
#include <queue>
#include <utility>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/hash_policy.hpp>
#define ll long long
#define ull unsigned long long
#define pb push_back
#define ri register int 
#define FO(x) {freopen(#x".in","r",stdin);freopen(#x".out","w",stdout);}
#define SIZE 1926081
using std::min;
using std::max;
using std::pair;
using std::queue;
using std::priority_queue;
using namespace __gnu_pbds;
inline char gc(){
    static char buf[SIZE],*p1=buf,*p2=buf;
    return p1==p2&&(p2=(p1=buf)+fread(buf,1,SIZE,stdin),p1==p2)?EOF:*p1++;
}
#define gc getchar
template <class T>inline void read(T &x){
    x=0;int ne=0;char c;
    while((c=getchar())>'9'||c<'0')ne=c=='-';x=c-48;
    while((c=getchar())>='0'&&c<='9')x=(x<<3)+(x<<1)+c-48;x=ne?-x:x;return ;
}
const int maxn=500005;
const int N=2000005;
const int inf=0x7fffffff;
int st[N<<2],top=0;
int sum[N<<2],hi[100005],fa[100005];
int rt[100005],ls[N<<2],rs[N<<2];
int n,m,q;
struct Dt{
    int x,id;
    bool operator <(const Dt &b)const{
        return x<b.x;
    }
}dt[100005];
inline void init(){for(ri i=(N<<2)-10;i>=1;i--)st[++top]=i;}
inline void del(int x){st[++top]=x,sum[x]=ls[x]=rs[x]=0;return ;}
inline int get(){int x=st[top--];sum[x]=ls[x]=rs[x]=0;return x;}
gp_hash_table <int,int> g;int tot=0;
ll f[maxn];
struct Edge{
    int x,y,dis;
    Edge(){x=y=dis=inf;}
    Edge(int _x,int _y,int _d){x=_x,y=_y,dis=_d;}
    bool operator <(const Edge &b)const{
        return dis<b.dis;
    }
}edge[maxn];
int pos;
int get(int x){return (fa[x]==x)?fa[x]:(fa[x]=get(fa[x]));}
void update(int &now,int l,int r){
    if(!now)now=get();
    sum[now]++;
    if(l==r)return ;
    int mid=(l+r)>>1;
    if(pos<=mid)update(ls[now],l,mid);
    else update(rs[now],mid+1,r);
    return ;
}
int query(int now,int l,int r,int k){
    //printf("%d %d %d %d %d %d\n",now,l,r,k,sum[rs[now]]);
    if(l==r){return l;}
    int mid=(l+r)>>1,t=sum[rs[now]];
    if(t>=k)return query(rs[now],mid+1,r,k);
    if(sum[ls[now]]<k-t)return -1;
    return query(ls[now],l,mid,k-t);
}
int merge(int x,int y){
    if(!x||!y)return x+y;
    sum[x]+=sum[y];
    ls[x]=merge(ls[x],ls[y]);
    rs[x]=merge(rs[x],rs[y]);
    del(y);
    return x;
}
int ans[maxn];
struct Query{
    int v,k,x,id;
    bool operator <(const Query &b)const{
        return x<b.x;
    }
}qry[maxn];
inline void solve(){
    int tp=1,x;
    int np=1,u,v;
    while(tp<=q){
        x=qry[tp].x;
        //printf("**%d %d %d**\n",x,tp,qry[tp].id);
        while(edge[np].dis<=x&&np<=m){
            u=edge[np].x,v=edge[np].y;
            //printf("--%d %d %d\n--\n",u,v,edge[np].dis);
            u=get(u),v=get(v);
            if(u!=v){
                merge(rt[u],rt[v]);        
                fa[v]=u;
            }   
            //puts("xx");
            np++;
        }
        //printf("(%d)\n",n);
        x=query(rt[get(qry[tp].v)],1,tot,qry[tp].k);
        if(x==-1)ans[qry[tp].id]=-1;
        else ans[qry[tp].id]=f[x];
        tp++;
    }
    for(ri i=1;i<=q;i++)printf("%d\n",ans[i]);
    return ;
}
int main(){
    int x,y,z;
    init();
    memset(ans,-1,sizeof(ans));
    read(n),read(m),read(q);
    for(ri i=1;i<=n;i++){
        read(dt[i].x);
        dt[i].id=fa[i]=i;    
    }
    std::sort(dt+1,dt+1+n);
    for(ri i=1;i<=n;i++){
        x=dt[i].x,y=dt[i].id;
        if(!g[x]){
            g[x]=++tot;
            f[tot]=x;
        }
        hi[y]=g[x];
        //pos=hi[y],update(rt[y],1,tot);
    }
    for(ri i=1;i<=n;i++){
        pos=hi[i];
        update(rt[i],1,tot);
    }
    for(ri i=1;i<=m;i++){
        read(edge[i].x),read(edge[i].y),read(edge[i].dis);
    }
    std::sort(edge+1,edge+1+m);
    for(ri i=1;i<=q;i++){
        read(qry[i].v),read(qry[i].x),read(qry[i].k);
        qry[i].id=i;
    }
    std::sort(qry+1,qry+1+q);
    solve();
    return 0;
}

转载于:https://www.cnblogs.com/Rye-Catcher/p/9763643.html

自我修炼的小石头
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
go学习笔记-文档-文档
07-21
go学习笔记-文档
知识点:线段树分裂
qq_35577488的博客
06-08 740
内容: 全名为:动态开点权值线段树的分裂 它是线段树合并的逆过程。实现过程类似于fhq平衡树的分裂. 应用场景: 具体实现:
线段树的分裂与合并
m0_62399304的博客
09-13 392
对于一些题目，可能两颗线段树要用到各自的节点信息，这时候线段树合并和分裂就可以完美的解决这类问题，比如说x树没有y中的一些节点，就可以直接利用y的节点信息，合并两颗线段树的时间复杂度是mlogm的。
线段树分裂与合并
weixin_44316314的博客
03-28 455
对于动态开点的线段树来说，当有很多棵线段树时，我们可以进行线段树合并，合并两棵线段树的复杂度为两棵线段树相同节点的数m*logm。 将y这棵线段树合并到x这棵线段树，对于x没有y有的节点，直接复制y的就行，x有y没有的不用管，都有的加起来即可。 void insert(int &now,int l,int r,int p,int v) //动态开点,将p位置的值加v { if( now == 0 ) now = ++cnt; if( l == r ) { a[now].maxt +=
【学习笔记】线段树的扩展（线段树的合并与分裂、可持久化线段树）
changle_cyx
12-02 6269
感觉最近研究数据结构，我的对拍能力和输出调试能力得到了显著提升…… 本篇文章介绍关于线段树的一些经典扩展操作。 有关线段树的经典问题（势能线段树、李超线段树、线段树维护单调子序列）的总结请看神仙 xyz32768xyz32768xyz32768 的这篇文章：[学习笔记]线段树骚操作选讲 1. 线段树的合并与分裂 1.1 BZOJ2212 我们考虑一道经典问题：BZOJ2212 题目大意：...
线段树 树状数组 离散化相关例题
baymax先生的博客
08-04 106
文章目录A—敌兵布阵B—Lost CowsG—Buy TicketE-----l Hate ItD-Just a HookF——Ultra-QuicksortH——StarsC—Major‘s postersI—A Simple Problem With Inteqers A—敌兵布阵 #include <iostream> #include <stdio.h> #include <algorithm> #include <string.h> #inc..
java学习笔记-Scokect.pdf
11-29
java学习笔记-Scokect.pdf
JSP学习笔记-2.pdf
11-28
JSP学习笔记-2.pdf
android学习笔记-clip.pdf
11-15
android学习笔记-clip.pdf
笔记-webpack5学习指南-V1.0
08-29
笔记-webpack5学习指南-V1.0
一类线段树合并与分裂相关总结
weixin_45539557的博客
02-12 343
一类线段树合并与分裂相关总结 这几天写了一些线段树合并与分裂相关的题目，来此总结一下。 什么叫线段树合并呢？事实上我个人认为应该叫动态开点权值线段树合并，顾名思义，就是将若干颗值域相同的线段树的信息合并到一颗线段树上。一般合并的信息都是当前值域值出现的个数等 下面来分析一下线段树合并的复杂度，两颗线段树合并的复杂度取决于最小的那颗树的重合点数，因为合并等同于删点，线段树合并通过动态开点保证了一次合并的复杂度是O(logn)O(logn)O(logn)的，所以对于mmm次在值域上的操作，复杂度可以近似看成O(
线段树合并、分裂
EricQian的博客
09-26 194
基本概念： 如果需要维护许多个大小为 \(10^5\) 级别的多重集，可以看做给每一个多重集建立一棵线段树。线段树的合并、分裂就是多重集的累加、分开。 这里使用动态开点的方式存储线段树树。 如果一个节点为空，那么它的编号为 \(0\) 。 变量释义： 有 \(cnt\) 个多重集 建立了 \(tot\) 个节点 若一个多重集的编号为 \(x\) ，它的根节点编号为 \(root[x]...
线段树合并
Cauchy的博客
05-21 2830
文章目录前置芝士线段树合并概念merge题目描述输入格式输出格式代码 前置芝士 权值线段树 动态开点线段树 线段树合并的全称为动态开点权值线段树合并 加个链接 线段树合并 概念 顾名思义，就是建立一棵新的线段树保存原有的两颗线段树的信息。 merge 线段树合并所完成的操作就是：在相同区间内，对应位置相加。 合并方式主要如下：两个相同区间的节点 p{p}p 和 q{q}q，合并区间 [l,r]{[l,r]}[l,r]。 若 p{p}p 和 q{q}q 有一者为 0{0}0，则另一者为根。 若 l=
权值线段树+线段树分裂/合并+CF1659D
R的博客
07-28 170
1
线段树合并，分裂和分治
Roll_Keyboard的博客
09-18 667
先说线段树合并 如果你会写主席树或者平时使用结构题那种线段树，那么理解起来就毫无压力。 首先从字面上理解，如果要合并两个线段树，用最暴力的方法，就是dfs一次，然后将信息合并到一颗线段树上，那么时间复杂度就取决于不同的节点数（因为如果是只有一棵线段树有的信息，直接不管即可）。 如果要合并很多个线段树，每个线段树只存了一点信息，那么自然不可能开满点，需要动态开点。这个就和主席树一样开即可。 解决了开...
线段树分裂合并
weixin_30276935的博客
02-06 217
线段树分裂合并 我先接触的是线段树合并所以先讲线段树合并。 首先，用来合并的线段树必须是动态开点的。线段树合并所做的事就是合并两棵动态开点线段树的信息，对于两棵动态开点线段树，可能会存在一些公共节点，我们所要做的就是合并这些节点的信息，然后把其他节点的信息继承。理清思路之后，剩下的事就是。设初始信息的个数是\(n\)，值域是\(m\)，对于每一个初始信息一次这样的操作是\(\log m\)的，而每...
loj 6189 Philosopher 线段树合并+线段树分裂+Splay
litble的成(tui)长(fei)史
01-15 685
这是一个悲伤的故事 别人在博弈论，我在哲学家； 别人在学数学，我在哲学家； 别人在吉司机，我在哲学家； 别人在剩余系，我在哲学家； 别人在改考试题，我TM还在哲学家； 首先，乘积的十进制最高位，可以就把每个数都取log，这样乘就变成了加，就不会大到爆炸。然后提取了和之后，去掉整数部分，pow一下就能得到十进制最高位了。 原序列看做若干权值线段树，一棵权值线段树里维护的元素是有序的，至于是升序...
python学习笔记--皮大庆
最新发布
08-14
《Python学习笔记》是由皮大庆编写的一本关于Python语言学习的教材。在这本书中，作者详细介绍了Python语言的基础知识、语法规则以及常用的编程技巧。 首先，作者简要介绍了Python语言的特点和优势。他提到，Python...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值