线段树&数链剖分

傻逼线段树,傻逼数剖

线段树

定义:

线段树是一种二叉搜索树,与区间树相似,它将一个区间划分成一些单元区间,每个单元区间对应线段树中的一个叶结点。
使用线段树可以快速的查找某一个节点在若干条线段中出现的次数,时间复杂度为O(logN)。而未优化的空间复杂度为2N,实际应用时一般还要开4N的数组以免越界,因此有时需要离散化让空间压缩。
有什么用?
线段树功能强大,支持区间求和,区间最大值,区间修改,单点修改等操作。
线段树的思想和分治思想很相像。
线段树的每一个节点都储存着一段区间[L…R]的信息,其中叶子节点L=R。它的大致思想是:将一段大区间平均地划分成2个小区间,每一个小区间都再平均分成2个更小区间……以此类推,直到每一个区间的L等于R(这样这个区间仅包含一个节点的信息,无法被划分)。通过对这些区间进行修改、查询,来实现对大区间的修改、查询。
这样一来,每一次修改、查询的时间复杂度都只为O(log2n)。
建树:
void build(int l,int r,int i){//建树,为当前左边界,r为右边界,i为编号 
     tree[i].l=l;//更新边界值
     tree[i].r=r;
     if(l==r){//如果是最底层的节点,sum就是本身
         tree[i].sum=input[l];
         return ;
    }
    int mid=(l+r)/2;
    build(l,mid,2*i);//左边部分建树
    build(mid+1,r,2*i+1);//右边部分建树
    tree[i].sum=(tree[2*i].sum+tree[2*i+1].sum)%mod;//递归返回时更新sum值
 }

 区间修改:

void add(int i,int L,int R,int k){//区间修改  ;
     if(tree[i].l>=L&&tree[i].r<=R){//被完全包含
         tree[i].sum=tree[i].sum+(tree[i].r-tree[i].l+1)*k; //修改区间
         tree[i].lazy+=k;//更新延迟标记
         return ;
    }
    push_down(i);//没有完全包含的话就先下传懒标记
    int mid=(tree[i].l+tree[i].r)/2;
    if(L<=mid) add(2*i,L,R,k);//左边有重合走左边
    if(mid<R) add(2*i+1,L,R,k);//右边有重合走右边
//这里一定不能写mid<=R,不然会死循环
    tree[i].sum=tree[2*i].sum+tree[2*i+1].sum//更新sum值
 }

区间查询:

int ask(int i,int L,int R){//区间查询 
     if(tree[i].l>=L&&tree[i].r<=R) return tree[i].sum;//完全包含,道理同区间修改
     push_down(i);//没有完全包含就下传延迟标记
     int ans=0;
     int mid=(tree[i].l+tree[i].r)/2;
     if(mid>=L) ans=(ans+ask(2*i,L,R));
     if(mid<R) ans=(ans+ask(2*i+1,L,R));//记录答案
     return ans;
 }

下传延迟标记(push_down操作):

void push_down(int i){//延迟标记下移 
     if(tree[i].lazy){
         tree[2*i].sum=(tree[2*i].sum+(tree[2*i].r-tree[2*i].l+1)* tree[i].lazy%mod)%mod;
         tree[2*i+1].sum=(tree[2*i+1].sum+(tree[2*i+1].r-tree[2*i+1].l+1)* tree[i].lazy%mod)%mod;
        tree[2*i].lazy+=tree[i].lazy;
        tree[2*i+1].lazy+=tree[i].lazy;
        tree[i].lazy=0; 
     }
 }

 

延迟标记的作用:

有些时候修改了也不一定会去查询,于是就打上延迟标记,需要的时候再下传。

板题:https://www.luogu.com.cn/problem/P3372

Code:

#include<bits/stdc++.h>
using namespace std;
const int N=1e5+5;
int n,m;
int type,x,y,k;
long long input[N];
struct node {
    int l;
    int r;
    long long sum;
    long long add;
} tree[N*4];

void spread(int i) {
    if(tree[i].add) {
        tree[2*i].sum+=tree[i].add*(tree[2*i].r-tree[2*i].l+1);
        tree[2*i+1].sum+=tree[i].add*(tree[2*i+1].r-tree[2*i+1].l+1);
        tree[2*i].add+=tree[i].add;
        tree[2*i+1].add+=tree[i].add;
        tree[i].add=0;
    }
}

void build(int i,int l,int r) {
    tree[i].l=l;
    tree[i].r=r;
    if(l==r) {
        tree[i].sum=input[l];
        return ;
    }
    int mid=(l+r)/2;
    build(2*i,l,mid);
    build(2*i+1,mid+1,r);
    tree[i].sum=tree[2*i].sum+tree[2*i+1].sum;
}

void change(int i,int l,int r,int k) {
    if(l<=tree[i].l&&r>=tree[i].r) {
        tree[i].sum+=k*(tree[i].r-tree[i].l+1);
        tree[i].add+=k;
        return ;
    }
    spread(i);
    int mid=(tree[i].l+tree[i].r)/2;
    if(l<=mid)change(2*i,l,r,k);
    if(r>mid)change(2*i+1,l,r,k);
    tree[i].sum=tree[2*i].sum+tree[2*i+1].sum;
}

long long check(int i,int l,int r) {
    if(l<=tree[i].l&&r>=tree[i].r) {
        return tree[i].sum;
    }
    spread(i);
    long long flag=0;
    int mid=(tree[i].l+tree[i].r)/2;
    if(l<=mid) flag+=check(2*i,l,r);
    if(r>mid) flag+=check(2*i+1,l,r);
    return flag;
}

int main() {
    cin>>n>>m;
    for(int i=1; i<=n; i++) {
        cin>>input[i];
    }
    build(1,1,n);
    for(int i=1; i<=m; i++) {
        cin>>type;
        if(type==1) {
            cin>>x>>y>>k;
            change(1,x,y,k);
        }
        if(type==2) {
            cin>>x>>y;
            cout<<check(1,x,y)<<endl;
        }
    }
    return 0;
}

 好的接下来来到——

树剖

定义:我们以某种规则将一棵树剖分成若干条竖直方向上的链,每次维护时可以一次跳一条链、并借助一些强大的线性数据结构来维护(通常链的数量很少),这样就大大优化了时间复杂度,足以解决很多线性结构搬到树上的题目。

 变量:

//son[N] 重儿子的编号,若没有重儿子则编号为-1
//size[N] 子树的大小
//f[N] 父亲节点的编号
//d[N] 结点的深度
//top[N] 所在链的链端
//id[N] 经过重链剖分后的新编号
//rk[N] 有rk[id[i]]=i

将树剖分成链的过程中,我们一共要进行两次dfs:

void dfs1(int x,int fa,int depth){//x:当前结点 fa:父结点 depth:当前结点深度 
     f[x]=fa;//更新父结点 
     d[x]=depth;//更新深度 
     size[x]=1;//子树大小初始化:根节点本身 
     for(int i=head[x];i;i=nex[i]){
         int y=ver[i];
         if(y==fa) continue ;
         dfs1(y,x,depth+1);
        if(size[y]>size[son[x]]) son[x]=y;//更新重儿子 
        size[x]+=size[y];//更新子树大小 
     }
     return ;
 } //dfs1更新f[N],d[N],size[N],son[N]
 void dfs2(int u,int t){//u为当前结点,t为链段 
     top[u]=t;
     id[u]=++cnt;
     rk[cnt]=u;//新的编号 
     if(!son[u]) return ;
     dfs2(son[u],t);//优先遍历重儿子,使一条链上编号连续 
     for(int i=head[u];i;i=nex[i]){
         int y=ver[i];
        if(y==son[u]||y==f[u]) continue; 
        dfs2(y,y);//再建一条链 
     } 
 }//dfs2更新top[N],id[N],rk[N]

至此我们剖分的过程就已经完成了,现在让我们看看在题目中树链剖分有什么用:

题目:https://www.luogu.com.cn/problem/P3384

 题目要求我们进行如下操作:

操作 1: 格式: 1 x y z 表示将树从 x 到 y 结点最短路径上所有节点的值都加上 z。(区间修改)

操作 2: 格式: 2 x y 表示求树从 x 到 y 结点最短路径上所有节点的值之和。(区间查询)

操作 3: 格式: 3 x z 表示将以 x 为根节点的子树内所有节点值都加上 z。(区间修改)

操作 4: 格式: 4 x 表示求以 x 为根节点的子树内所有节点值之和。(区间查询)

操作一:

void func1(int x,int y,int k){//将树从 x到 y结点最短路径上所有节点的值都加上k
     if(d[x]<d[y]) swap(x,y); 
     while(top[x]!=top[y]){//循环,直到这两个点处于同一条链 
         if(d[top[x]]<d[top[y]]) swap(x,y);//规范 
         add(1,id[top[x]],id[x],k);
         x=f[top[x]];
     }
     if(d[x]>d[y]) swap(x,y);//深度较浅的一定是序号较小的 
     add(1,id[x],id[y],k);
 }
 

 

其实原理就和倍增求LCA差不多。

操作二:

void func2(int x,int y){
     int ans=0;
     while(top[x]!=top[y]){
         if(d[top[x]]<d[top[y]]) swap(x,y);
         ans=(ans+ask(1,id[top[x]],id[x]))%mod;
         x=f[top[x]];
     }
     if(d[x]>d[y]) swap(x,y);//道理同上 
     ans=(ans+ask(1,id[x],id[y]));
     cout<<ans%mod<<endl;
 }

 

原理和func1差不多啦~

操作三&&操作四:

这里的处理比较巧妙。

在树剖中,一条链的编号是连续的,因此一棵子树的编号也是连续的。

所以直接用线段树的区间修改和区间查询操作就行了。

Code:

#include<bits/stdc++.h>
#define int long long
using namespace std;
const int N=1e6+5;
int n,m,root,mod;
int idx=0;
 struct node{
     int l;
     int r;
     int sum;
     int lazy;
 }tree[4*N];
 int head[N],ver[2*N],nex[2*N],son[N],size[N],f[N],d[N],top[N],id[N],rk[N];
 int input[N];
 int cnt=0;
 void add_e(int x,int y){
     ver[++idx]=y;
     nex[idx]=head[x];
     head[x]=idx;
 }
 
 void build(int l,int r,int i){//常规建树 
     tree[i].l=l;
     tree[i].r=r;
     if(l==r){
         tree[i].sum=input[rk[l]]%mod;
         return ;
    }
    int mid=(l+r)/2;
    build(l,mid,2*i);
    build(mid+1,r,2*i+1);
    tree[i].sum=(tree[2*i].sum+tree[2*i+1].sum)%mod;
 }
 
 void push_down(int i){//延迟标记下移 
     if(tree[i].lazy){
         tree[2*i].sum=(tree[2*i].sum+(tree[2*i].r-tree[2*i].l+1)* tree[i].lazy%mod)%mod;
         tree[2*i+1].sum=(tree[2*i+1].sum+(tree[2*i+1].r-tree[2*i+1].l+1)* tree[i].lazy%mod)%mod;
        tree[2*i].lazy+=tree[i].lazy;
        tree[2*i+1].lazy+=tree[i].lazy;
        tree[i].lazy=0; 
     }
 }
 
 int ask(int i,int L,int R){//区间查询 
     if(tree[i].l>=L&&tree[i].r<=R) return tree[i].sum;
     push_down(i);
     int ans=0;
     int mid=(tree[i].l+tree[i].r)/2;
     if(mid>=L) ans=(ans+ask(2*i,L,R))%mod;
     if(mid<R) ans=(ans+ask(2*i+1,L,R))%mod;
     return ans%mod;
 }
 
 void add(int i,int L,int R,int k){//区间修改  ;
     if(tree[i].l>=L&&tree[i].r<=R){
         tree[i].sum=(tree[i].sum+(tree[i].r-tree[i].l+1)*k%mod)%mod; 
         tree[i].lazy+=k;
         return ;
    }
    push_down(i);
    int mid=(tree[i].l+tree[i].r)/2;
    if(L<=mid) add(2*i,L,R,k);
    if(mid<R) add(2*i+1,L,R,k);
    tree[i].sum=(tree[2*i].sum+tree[2*i+1].sum)%mod;
 }
 
 void dfs1(int x,int fa,int depth){//x:当前结点 fa:父结点 depth:当前结点深度 
     f[x]=fa;//更新父结点 
     d[x]=depth;//更新深度 
     size[x]=1;//子树大小初始化:根节点本身 
     for(int i=head[x];i;i=nex[i]){
         int y=ver[i];
         if(y==fa) continue ;
         dfs1(y,x,depth+1);
        if(size[y]>size[son[x]]) son[x]=y;//更新重儿子 
        size[x]+=size[y];//更新子树大小 
     }
     return ;
 } 
 
 void dfs2(int u,int t){//u为当前结点,t为链段 
     top[u]=t;
     id[u]=++cnt;
     rk[cnt]=u;//新的编号 
     if(!son[u]) return ;
     dfs2(son[u],t);//优先遍历重儿子,使一条链上编号连续 
     for(int i=head[u];i;i=nex[i]){
         int y=ver[i];
        if(y==son[u]||y==f[u]) continue; 
        dfs2(y,y);//再建一条链 
     } 
 }
 
 void func1(int x,int y,int k){//将树从 x到 y结点最短路径上所有节点的值都加上k
     if(d[x]<d[y]) swap(x,y); 
     while(top[x]!=top[y]){//循环,直到这两个点处于同一条链 
         if(d[top[x]]<d[top[y]]) swap(x,y);//规范 
         add(1,id[top[x]],id[x],k);
         x=f[top[x]];
     }
     if(d[x]>d[y]) swap(x,y);//深度较浅的一定是序号较小的 
     add(1,id[x],id[y],k);
 }
 
 void func2(int x,int y){
     int ans=0;
     while(top[x]!=top[y]){
         if(d[top[x]]<d[top[y]]) swap(x,y);
         ans=(ans+ask(1,id[top[x]],id[x]))%mod;
         x=f[top[x]];
     }
     if(d[x]>d[y]) swap(x,y);//道理同上 
     ans=(ans+ask(1,id[x],id[y]));
     cout<<ans%mod<<endl;
 }
signed main(){
    cin>>n>>m>>root>>mod;
    for(int i=1;i<=n;i++){
        cin>>input[i];//输入节点初始值 
    }
    for(int i=1;i<=n-1;i++){
        int x,y;
        cin>>x>>y; 
        add_e(x,y);
        add_e(y,x);//建图 
    }
    dfs1(root,0,1);//第一次dfs求son,depth,f,size 
    dfs2(root,root);//第二次dfs求id,rk,将树拆成链表 
    build(1,n,1);//建树 
    for(int i=1;i<=m;i++){
        int type;
        cin>>type;
        if(type==1){
            int x,y,z;
            cin>>x>>y>>z;
            func1(x,y,z);
        }
        if(type==2){
            int x,y;
            cin>>x>>y;
            func2(x,y);
        }
        if(type==3){
            int x,z;
            cin>>x>>z;
            add(1,id[x],id[x]+size[x]-1,z);
        }
        if(type==4){
            int x;
            cin>>x;
            cout<<ask(1,id[x],id[x]+size[x]-1)%mod<<endl;
        }
    } 
    return 0;
}

 

完结撒花*★,°*:.☆( ̄▽ ̄)/$:*.°★* 。

 

 

 

 

 

 
posted @ 2021-02-23 17:53  爆零王  阅读(9)  评论(0编辑  收藏