【康复训练】线段树

如题。

线段树板子：

P3372 【模板】线段树 1

建树

build_tree(1,1,n)从上到下建树，如果l=r证明是叶子节点，将a[l]存入，然后再递归上去。
代码实现是这样：

void build_tree(int id,int l,int r){
    t[id].le=l;t[id].ri=r;
    if(l==r){
        t[id].w=a[l];
        return;
    }
    ll mid=(l+r)>>1;
    build_tree(id<<1,l,mid);
    build_tree((id<<1)+1,mid+1,r);
    addup(id);
}

单点修改

这个点在mid左边就找左子树，在mid右边就找右子树，l=r就算找到了，直接修改，然后递归更新上去。

单点查询

和上面的一样，甚至不用递归更新，直接输出出来就行。

区间修改

现在访问的树节点在修改区间内，直接全部修改，然后打上懒标记。

懒标记：只有访问到该区间的时候将该区间的修改值下放到子节点，这样有些被修改却没有被查询到的节点就不用下传递归，节省时间复杂度。

如果完全不在，直接return。

如果有交叉，左右节点都递推下去就好了，return大人会解决一切的。

void update(int id,int l,int r,int x,int y,ll val){
    if(x>r||y<l)    return;
    if(x<=l&&r<=y){
        t[id].w+=val*(r-l+1);
        t[id].lazy+=val;
        return;
    }
    int mid=(l+r)>>1;
    push_down(id,l,r,mid);
    update(id<<1,l,mid,x,y,val);
    update((id<<1)+1,mid+1,r,x,y,val);
    addup(id);
}

区间查询

没什么可说的。

ll ask(int id,int l,int r,int x,int y){
    if(x>r||y<l)    return 0;
    if(x<=l&&r<=y)  return t[id].w;
    int mid=(l+r)>>1;
    push_down(id,l,r,mid);
    return ask(id<<1,l,mid,x,y)+ask((id<<1)+1,mid+1,r,x,y);
}

完整代码

#include<bits/stdc++.h>
using namespace std;
#define rg register int
#define il inline
// #define int long long
typedef long double llf;
typedef long long ll;
typedef pair<int,int> PII;
const double eps=1e-8;
namespace io{
    il ll read(){
        char c=getchar();
        ll x=0;int f=1;
        while(c<48){if(c=='-')f=-1;c=getchar();}
        while(c>47)x=(x*10)+(c^48),c=getchar();
        return x*f;
    }//快读
    il int ins(char *str){
        int len=0;
        while(1){
            char c=getchar();
            if(c!='\n' && c!='\0' && c!='\r') str[++len]=c;
            else{
                //if(len=0) continue;
                break;
            }
        }
        return len;
    }//字符串快读，下标从1开始
}
using namespace io;
namespace mystd{
    il int Max(int a,int b){if(a<b)return b;return a;}
    il int Min(int a,int b){if(a>b)return b;return a;}
    il int Abs(int a){if(a<0) return a*(-1);return a;}
    il double fMax(double a,double b){if (a<b)return b;return a;}
    il double fMin(double a,double b){if (a>b)return b;return a;}
    il double fAbs(double a){if (a<0)return a*(-1);return a;}
    il int dcmp(double a){
        if(a<-eps)  return -1;
        if(a>eps)   return 1;
        return 0;
    }
}
const int maxn=100005;
ll n,m,a[maxn];
struct tree{
    ll le,ri,w;
    ll lazy;//懒标记的值已在本节点加过，只有下传子节点时需要使用
};tree t[maxn<<2];
void addup(int id){
    t[id].w=t[id<<1].w+t[(id<<1)+1].w;
}
void build_tree(int id,int l,int r){
    t[id].le=l;t[id].ri=r;
    if(l==r){
        t[id].w=a[l];
        return;
    }
    ll mid=(l+r)>>1;
    build_tree(id<<1,l,mid);
    build_tree((id<<1)+1,mid+1,r);
    addup(id);
}
void push_down(int id,int l,int r,int mid){
    t[id<<1].w+=t[id].lazy*(mid-l+1);
    t[(id<<1)+1].w+=t[id].lazy*(r-mid);
    t[id<<1].lazy+=t[id].lazy;
    t[(id<<1)+1].lazy+=t[id].lazy;
    t[id].lazy=0;
}
ll ask(int id,int l,int r,int x,int y){
    if(x>r||y<l)    return 0;
    if(x<=l&&r<=y)  return t[id].w;
    int mid=(l+r)>>1;
    push_down(id,l,r,mid);
    return ask(id<<1,l,mid,x,y)+ask((id<<1)+1,mid+1,r,x,y);
}
void update(int id,int l,int r,int x,int y,ll val){
    if(x>r||y<l)    return;
    if(x<=l&&r<=y){
        t[id].w+=val*(r-l+1);
        t[id].lazy+=val;
        return;
    }
    int mid=(l+r)>>1;
    push_down(id,l,r,mid);
    update(id<<1,l,mid,x,y,val);
    update((id<<1)+1,mid+1,r,x,y,val);
    addup(id);
}
void input(){
    n=read(),m=read();
    for(rg i=1;i<=n;++i)    a[i]=read();
}
int main(){
    // freopen("3372.in","r",stdin);
    // freopen("3372.out","w",stdout);
    input();
    build_tree(1,1,n);
    ll x,y;
    for(int i=1;i<=m;++i){
        int in;
        in=read(),x=read(),y=read();
        if(in==2)   printf("%lld\n",ask(1,1,n,x,y));
        else{
            ll val;val=read();
            if(val!=0)  update(1,1,n,x,y,val);
        }
    }
}

3924

很容易发现，线段树的结构是静态的。

初始状态（建树），每个节点的期望等于其子节点期望之和除以 $2$ 加上该节点权值和。

在更新时，因为树的结构是静态的，所以把该节点当作根节点，其期望就要加上 $x\times k$ （$k$ 是一个贡献系数）

时间复杂度 $O(nlogn)$，但是本题卡常，所以荣获70pts。

#include<bits/stdc++.h>
using namespace std;
#define rg register int
#define il inline
// #define int long long
typedef long double llf;
typedef long long ll;
typedef pair<int,int> PII;
const double eps=1e-8;
namespace io{
    il ll read(){
        char c=getchar();
        ll x=0;int f=1;
        while(c<48){if(c=='-')f=-1;c=getchar();}
        while(c>47)x=(x*10)+(c^48),c=getchar();
        return x*f;
    }//快读
    il int ins(char *str){
        int len=0;
        while(1){
            char c=getchar();
            if(c!='\n' && c!='\0' && c!='\r') str[++len]=c;
            else{
                //if(len=0) continue;
                break;
            }
        }
        return len;
    }//字符串快读，下标从1开始
}
using namespace io;
namespace mystd{
    il int Max(int a,int b){if(a<b)return b;return a;}
    il int Min(int a,int b){if(a>b)return b;return a;}
    il int Abs(int a){if(a<0) return a*(-1);return a;}
    il double fMax(double a,double b){if (a<b)return b;return a;}
    il double fMin(double a,double b){if (a>b)return b;return a;}
    il double fAbs(double a){if (a<0)return a*(-1);return a;}
    il int dcmp(double a){
        if(a<-eps)  return -1;
        if(a>eps)   return 1;
        return 0;
    }
}

const int maxn=1000005;
int n,m,qwq,a[maxn];
struct Tree{
    int id,le,ri;
    ll w,lazy;
    double e,k;
};Tree t[maxn<<2];

il void push_up(int id){
    t[id].w=t[id<<1].w+t[id<<1|1].w;
    t[id].e=(t[id<<1].e+t[id<<1|1].e)/2.0+t[id].w;
}

il void push_down(int id,int l,int r,int mid){
    if(!t[id].lazy) return;
    t[id<<1].w+=t[id].lazy*(mid-l+1);t[id<<1|1].w+=t[id].lazy*(r-mid);
    t[id<<1].e+=(double)t[id].lazy*t[id<<1].k;t[id<<1|1].e+=(double)t[id].lazy*t[id<<1|1].k;
    t[id<<1].lazy+=t[id].lazy;t[id<<1|1].lazy+=t[id].lazy;
    t[id].lazy=0;
}

il void update(int id,int l,int r,int x,int y,ll val){
    if(x>r || y<l)  return;
    if(x<=l && r<=y){
        t[id].w+=val*(r-l+1);
        t[id].e+=(double)val*t[id].k;
        t[id].lazy+=val;
        return;
    }
    int mid=(l+r)>>1;
    push_down(id,l,r,mid);
    update((id<<1),l,mid,x,y,val);update((id<<1)+1,mid+1,r,x,y,val);
    push_up(id);
}

il void build_tree(int id,int l,int r){
    t[id].le=l,t[id].ri=r;
    if(l==r){
        t[id].w=a[l],t[id].e=a[l],t[id].k=1.0;
        return;
    }
    int mid=l+r>>1;
    build_tree(id<<1,l,mid);
    build_tree(id<<1|1,mid+1,r);
    t[id].k=(t[id<<1].k+t[id<<1|1].k)/2.0+(double)(r-l+1);
    push_up(id);
}

il void input(){
    n=read(),m=read(),qwq=read();
    for(rg i=1;i<=n;++i)    a[i]=read();
}

int main(){
    // freopen("3924.in","r",stdin);
    // freopen("3924.out","w",stdout);
    input();
    build_tree(1,1,n);
    int l,r,x;
    for(rg i=1;i<=m;++i){
        l=read(),r=read(),x=read();
        update(1,1,n,l,r,x);
        printf("%.0lf\n",t[1].e*qwq);
    }
    return 0;
}

那么考虑发现，由于这道题的线段树结构是静态的，区间修改中每一个点对根节点的贡献系数就是不变的，可以做一个差分。

对于一个节点，它的贡献系数是 $\sum _{i=1}^{dep}$$\frac{1}{2^{i-1}}=\frac{1-(\frac{1}{2}{)}^{dep}}{\frac{1}{2}}=\frac{2^{dep}-1}{2^{dep-1}}$。

对其维护一个前缀和数组 s[i]，当修改操作进行差分，就可以得到本次修改操作对根节点的贡献。

时间复杂度为 $O(n)$。

#include<bits/stdc++.h>
using namespace std;
#define rg register int
#define il inline
// #define int long long
typedef long double llf;
typedef long long ll;
typedef pair<int,int> PII;
const double eps=1e-8;
namespace io{
    il ll read(){
        char c=getchar();
        ll x=0;int f=1;
        while(c<48){if(c=='-')f=-1;c=getchar();}
        while(c>47)x=(x*10)+(c^48),c=getchar();
        return x*f;
    }//快读
    il int ins(char *str){
        int len=0;
        while(1){
            char c=getchar();
            if(c!='\n' && c!='\0' && c!='\r') str[++len]=c;
            else{
                //if(len=0) continue;
                break;
            }
        }
        return len;
    }//字符串快读，下标从1开始
}
using namespace io;
namespace mystd{
    il int Max(int a,int b){if(a<b)return b;return a;}
    il int Min(int a,int b){if(a>b)return b;return a;}
    il int Abs(int a){if(a<0) return a*(-1);return a;}
    il double fMax(double a,double b){if (a<b)return b;return a;}
    il double fMin(double a,double b){if (a>b)return b;return a;}
    il double fAbs(double a){if (a<0)return a*(-1);return a;}
    il int dcmp(double a){
        if(a<-eps)  return -1;
        if(a>eps)   return 1;
        return 0;
    }
}

const int maxn=1000005;
int n,m,qwq,g,a[maxn],dep[maxn],maxd;
ll s[maxn],ans,k;
struct Tree{
    int id,le,ri;
    ll w;
};Tree t[maxn<<2];

il void push_up(int id){
    t[id].w=t[id<<1].w+t[id<<1|1].w;
}

int gcd(int x,int y){
    if(y==0)	return x;
	else	return gcd(y,x%y);
}

il void build_tree(int id,int l,int r,int deep){
    t[id].le=l,t[id].ri=r;
    if(l==r){
        t[id].w=a[l];dep[l]=deep;maxd=mystd::Max(maxd,deep);
        return;
    }
    int mid=l+r>>1;
    build_tree(id<<1,l,mid,deep+1);build_tree(id<<1|1,mid+1,r,deep+1);
    push_up(id);
}

il ll ask(int id,int l,int r,int deep,ll val){
    if(l==r)    return 1ll*(1ll<<deep)*(val+t[id].w);
    int mid=(l+r)>>1;
    return ask(id<<1,l,mid,deep-1,val+t[id].w)+ask(id<<1|1,mid+1,r,deep-1,val+t[id].w);
}//得到初始期望和

il void input(){
    n=read(),m=read(),qwq=read();
    for(rg i=1;i<=n;++i)    a[i]=read();
}

int main(){
    // freopen("3924.in","r",stdin);
    // freopen("3924.out","w",stdout);
    input();
    build_tree(1,1,n,1);
    ans=ask(1,1,n,maxd-1,0);
    k=1ll<<(maxd-1);
    g=gcd(k,qwq);qwq/=g,k/=g;//求qwq和k的最大公约数，防爆精度
    for(rg i=1;i<=n;++i)    s[i]=s[i-1]+1ll*((1ll<<dep[i])-1)*(1ll<<(maxd-dep[i]));//一乘一除，使分母是2^(dep-1)
    int l,r,x;
    for(rg i=1;i<=m;++i){
        l=read(),r=read(),x=read();
        ans+=1ll*(s[r]-s[l-1])*x;
        printf("%lld\n",ans/k*qwq);
    }
    return 0;
}