zkw线段树学习笔记

ZKW线段树

应某迪要求，写一篇数据结构学习笔记。

实际上还没有学很多东西，只是一些基础的操作。

zkw线段树的学习资料，网上有很多，这里记录的只是自己的一些理解。

 

 

建树

inline void build(){
    for(bit=1,n=read();bit<=n+1;bit<<=1);
    for(int i=bit+1;i<=bit+n;++i) sum[i]=read();
    for(int i=bit-1;i;--i) sum[i]=sum[i<<1]+sum[i<<1|1];
}

$zkw$线段树构造了一棵完美二叉树，只有最后一层叶子节点管辖的区间大小为1。

$zkw$线段树是基于位运算的，对于节点$p$，$p<<1$为它的左儿子，$p<<1|1$为它的右儿子。

因为是一棵完美二叉树，除掉叶子节点的部分一定为$2^k-1$的形式，将这个$2^k$记为$bit$，可以方便我们之后的操作。

其意义是，对于原序列的点$i$，可以直接得到对应线段树上的节点$i+bit$。

注意这里我们忽略了$bit$也就是$2^k$这一个节点，以后再提。

同时建树的一个细节是$bit$应当大于$n+1$，其原因也可以留到后面。

 

 

单点修改

inline void modify(int p,int val){
    for(p+=bit;p;p>>=1) sum[p]+=val;
}

找到位置之后，直接修改一条祖先链。

 

 

区间修改

inline void modify(int l,int r,int val){
    int lc=0,rc=0,len=1;
    for(l+=bit-1,r+=bit+1;l^r^1;l>>=1,r>>=1,len<<=1){
        sum[l]+=lc*val; sum[r]+=rc*val;
        if(~l&1) sum[l^1]+=len*val,add[l^1]+=val,lc+=len;
        if(r&1) sum[r^1]+=len*val,add[r^1]+=val,rc+=len;
    }
    for(;l;l>>=1,r>>=1) sum[l]+=lc*val,sum[r]+=rc*val;
}

$lc$：当前左指针包含的区间长度。$rc$：当前右指针包含的区间长度。$len$：当前翻到的节点层管辖区间的长度。

这里我们将$l$，$r$都作为开区间。所以分别加$bit-1$，$bit+1$处理。

因为操作是自下而上进行的，$zkw$线段树一般不维护懒标记，

因而我们用一个数组$add$进行标记永久化，表示这个区间的所有序列应该被加上这个值，显然这个值是不能下传的。

当$l$的最后一位为0，也就是说$l$指针为左儿子，那么l的右兄弟在当前修改的区间内。

同理$r$的左兄弟会在修改区间内。

当$l$，$r$两个指针已经成为兄弟，也就是说二者在二进制下只有最后一位不同，即异或值为1，那么全部的修改操作已经完成，可以结束。

然而祖先链上的$sum$值仍然需要修改。

这里可以解释，为什么$bit$应该大于$n+1$而不是$n$，为什么$bit+0$这个节点需要被空出来，因为我们需要开区间来进行操作。

然而似乎使$bit$仅保证大于$n$的打法是正确的，手玩确实没有错误。

 

 

单点查询

inline int query(int p){
    int ans=0;
    for(p+=bit,ans=sum[p],p>>=1;p;p>>=1) ans+=add[p];
    return ans;
}

统计叶子节点的$sum$值，并不断加上祖先链的$add$标记即可。

应当注意的是不要加上叶子节点的$add$标记，这个标记是无意义的。

 

 

区间查询

inline int query(int l,int r){
    int ans=0,lc=0,rc=0,len=1;
    for(l+=bit-1,r+=bit+1;l^r^1;l>>=1,r>>=1,len<<=1){
        ans+=add[l]*lc+add[r]*rc;
        if(~l&1) ans+=sum[l^1],lc+=len;
        if(r&1) ans+=sum[r^1],rc+=len;
    }
    for(;l;l>>=1,r>>=1) ans+=add[l]*lc+add[r]*rc;
    return ans;
}

区间查询的打法是类似于区间修改的。

首先将$l$，$r$设为开区间。

不断翻祖先链，记得加上兄弟节点整体的$sum$值和祖先链上部分的$add$标记就可以了。

应当注意的是循环中统计$add$标记和兄弟$sum$值的顺序不可交换，否则可能导致$lc$，$rc$变量维护的含义错误。

 

 

区间最值

思想大概是将儿子的最值不断差分到父亲身上。

因为不同的部分已经被差分掉，可以直接修改区间的最值。

应当注意的是，区间最值的求法与区间求和不同。

为了减少特判，原本的开区间被转化为闭区间。

但这样产生一个问题，如果查询区间长度为1会导致一些问题：左右端点永远不会成为兄弟，故导致了死循环。

所以要加一个单点查询的特判。

因为要维护区间最值，修改操作同时也要不断差分，于是打的麻烦了许多，代码可以参考下面。

 

 

基础操作

#include<bits/stdc++.h>
using namespace std;
const int N=1e6+7;
inline int read(register int x=0,register char ch=getchar(),register int f=0){
    while(!isdigit(ch)) f=ch=='-',ch=getchar();
    while(isdigit(ch)) x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
    return f?-x:x;
}
int n,m,bit;
int sum[N<<2],add[N<<2],mn[N<<2],mx[N<<2];
inline void build(){
    for(bit=1;bit<=n+1;bit<<=1);
    for(int i=bit+1;i<=bit+n;++i) mx[i]=mn[i]=sum[i]=read();
    for(int i=bit-1;i;--i){
        sum[i]=sum[i<<1]+sum[i<<1|1];
        mn[i]=min(mn[i<<1],mn[i<<1|1]); mn[i<<1]-=mn[i]; mn[i<<1|1]-=mn[i];
        mx[i]=max(mx[i<<1],mx[i<<1|1]); mx[i<<1]-=mx[i]; mx[i<<1|1]-=mx[i];
    }
}
inline int query(int p){
    int ans=0;
    for(p+=bit,ans=sum[p],p>>=1;p;p>>=1) ans+=add[p];
    return ans;
}
inline int query(int l,int r){
    int ans=0,lc=0,rc=0,len=1;
    for(l+=bit-1,r+=bit+1;l^r^1;l>>=1,r>>=1,len<<=1){
        ans+=add[l]*lc+add[r]*rc;
        if(~l&1) ans+=sum[l^1],lc+=len;
        if(r&1) ans+=sum[r^1],rc+=len;
    }
    for(;l;l>>=1,r>>=1) ans+=add[l]*lc+add[r]*rc;
    return ans;
}
inline int query_min(int l,int r){
    if(l==r) return query(l);
    int lans=0,rans=0;
    for(l+=bit,r+=bit;l^r^1;l>>=1,r>>=1){
        lans+=mn[l]; rans+=mn[r];
        if(~l&1) lans=min(lans,mn[l^1]);
        if(r&1) rans=min(rans,mn[r^1]);
    }
    for(lans=min(lans+mn[l],rans+mn[r]),l>>=1;l;l>>=1) lans+=mn[l];
    return lans;
}
inline int query_max(int l,int r){
    if(l==r) return query(l);
    int lans=0,rans=0;
    for(l+=bit,r+=bit;l^r^1;l>>=1,r>>=1){
        lans+=mx[l]; rans+=mx[r];
        if(~l&1) lans=max(lans,mx[l^1]);
        if(r&1) rans=max(rans,mx[r^1]);
    }
    for(lans=max(lans+mx[l],rans+mx[r]),l>>=1;l;l>>=1) lans+=mx[l];
    return lans;
}
inline void modify(int l,int r,int val){
    int lc=0,rc=0,len=1,x;
    for(l+=bit-1,r+=bit+1;l^r^1;l>>=1,r>>=1,len<<=1){
        sum[l]+=lc*val; sum[r]+=rc*val;
        if(~l&1) sum[l^1]+=len*val,add[l^1]+=val,mn[l^1]+=val,lc+=len;
        if(r&1) sum[r^1]+=len*val,add[r^1]+=val,mn[r^1]+=val,rc+=len;
        x=min(mn[l],mn[l^1]); mn[l]-=x; mn[l^1]-=x; mn[l>>1]+=x;
        x=min(mn[r],mn[r^1]); mn[r]-=x; mn[r^1]-=x; mn[r>>1]+=x;
    }
    for(;l;l>>=1,r>>=1){
        sum[l]+=lc*val; sum[r]+=rc*val;
        x=min(mn[l],mn[l^1]); mn[l]-=x; mn[l^1]-=x; mn[l>>1]+=x;
        x=max(mx[l],mx[l^1]); mx[l]-=x; mx[l^1]-=x; mx[l>>1]+=x;
    }
}
inline void modify(int p,int val){
    int x;
    for(p+=bit;p;p>>=1){
        sum[p]+=val; mn[p]+=val; mx[p]+=val;
        x=min(mn[p],mn[p^1]); mn[p]-=x; mn[p^1]-=x; mn[p>>1]+=x;
        x=max(mx[p],mx[p^1]); mx[p]-=x; mx[p^1]-=x; mx[p>>1]+=x;
    }
}
int main(){
    n=read();
    build();
    return 0;
}

 

 

区间信息合并（山海经）

思想大概与区间查询最值一致。

为了减少特判将开区间转化为闭区间。

需要注意的是信息合并有左右的先后顺序。

所以左右指针的写法并不相同，最后将$l$，$r$扫过的信息合并就可以了。

#include<bits/stdc++.h>
const int N=100010;
inline int read(register int x=0,register char ch=getchar(),bool f=0){
    while(!isdigit(ch)) f=ch=='-',ch=getchar();
    while(isdigit(ch)) x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
    return f?-x:x;
}
struct Ans{
    int l,r,val;
};
struct Node{
    Ans la,ra,mx,tot;
}s[N<<2];
int n,m,bit;
inline bool operator <(const Ans &a,const Ans &b){
    return a.val<b.val||(a.val==b.val&&a.l>b.l)||(a.val==b.val&&a.l==b.l&&a.r>b.r);
}
inline Ans operator +(const Ans &a,const Ans &b){
    return (Ans){a.l,b.r,a.val+b.val};
}
inline Node operator +(const Node &a,const Node &b){
    return (Node){std::max(a.la,a.tot+b.la),std::max(b.ra,a.ra+b.tot),std::max(std::max(a.mx,b.mx),a.ra+b.la),a.tot+b.tot};
}
void build(){
    for(bit=1;bit<=n+1;bit<<=1);
    for(int i=bit+1;i<=bit+n;++i) s[i].tot=s[i].mx=s[i].la=s[i].ra=(Ans){i-bit,i-bit,read()};
    for(int i=bit-1;i;--i) s[i]=s[i<<1]+s[i<<1|1];
}
Ans query(int r,int l){
    if(l==r) return s[l+bit].mx;
    Node L=s[l+bit],R=s[r+bit];
    for(l+=bit,r+=bit;l^r^1;l>>=1,r>>=1){
        if(~l&1) L=L+s[l^1];
        if(r&1) R=s[r^1]+R;
    }
    return (L+R).mx;
}
void print(const Ans &x){
    printf("%d %d %d\n",x.l,x.r,x.val);
}
int main(){
    n=read(); m=read(); build();
    for(int i=1;i<=m;++i) print(query(read(),read()));
    return 0;
}