洛谷——P3373 【模板】线段树 2&& B 数据结构

P3373 【模板】线段树 2

题目描述

如题，已知一个数列，你需要进行下面三种操作：

1.将某区间每一个数乘上x

2.将某区间每一个数加上x

3.求出某区间每一个数的和

线段树维护区间乘法

1.如何修改？

　　一个数去乘区间里的每一个数，那么这个区间的和会乘以这个数，需要乘法标记，初始化为1，乘法标记要乘以这个数，来下传到他的子树中，即更新他的子区间，当然，他的加法标记也要乘以这个数。

2.如何更新？

他子树的值=它的乘法标记*它子树的值+他子树的区间长度*它的加法标记

乘法标记更新，加法标记更新

某位大佬的线段树

#include<bits/stdc++.h>
#define N 4000000
#define LL long long
#define RE register
#define IN inline 

using namespace std;

IN void in(LL &x){
    RE char c=getchar();x=;int f=;
    while(!isdigit(c)) {if(c=='-') f=-;c=getchar();}
    while(isdigit(c)){x=x*+c-'';c=getchar();}
    x*=f;
}

/*
1.将某区间每一个数乘上x

2.将某区间每一个数加上x

3.求出某区间每一个数的和
*/

LL n,m,X,ans,p;
struct node{
    LL l,r,w,f,mul;
}e[N];

IN void build(LL k,LL l,LL r){
    e[k].l=l;e[k].r=r;e[k].mul=;e[k].f=;
    if(l==r){
        in(e[k].w);return;
    }LL mid=(l+r)/;
    build(k*,l,mid);build(k*+,mid+,r);
    e[k].w=(e[k*].w+e[k*+].w)%p;
}

IN void down(LL k){
    LL mu=e[k].mul,ll=e[k].l,rr=e[k].r,mid=(ll+rr)/;
    e[k*].w=(e[k*].w*mu+e[k].f*(mid-ll+))%p;
    e[k*+].w=(e[k*+].w*mu+e[k].f*(rr-mid))%p;

    e[k*].mul=(e[k*].mul*mu)%p;
    e[k*+].mul=(e[k*+].mul*mu)%p;

    e[k*].f=(e[k*].f*mu+e[k].f)%p;
    e[k*+].f=(e[k*+].f*mu+e[k].f)%p;

    e[k].f=;e[k].mul=;
}

IN void mull(LL k,LL l,LL r){
    LL ll=e[k].l,rr=e[k].r,mid=(ll+rr)/;
    if(ll>=l&&rr<=r){
        e[k].w=(e[k].w*X)%p;
        e[k].mul=(e[k].mul*X)%p;
        e[k].f=(e[k].f*X)%p;
        return ;
    }if(e[k].f!=||e[k].mul!=) down(k);
    if(l<=mid) mull(k*,l,r);if(r>mid) mull(k*+,l,r);
    e[k].w=(e[k*].w+e[k*+].w)%p;
}

IN void change_LLerval(LL k,LL l,LL r){
    LL ll=e[k].l,rr=e[k].r,mid=(ll+rr)/;
    if(ll>=l&&rr<=r){
        e[k].f=(e[k].f+X)%p;
        e[k].w=((rr-ll+)*X+e[k].w)%p;return ;
    }if(e[k].f!=||e[k].mul!=) down(k);
    if(l<=mid) change_LLerval(k*,l,r);if(r>mid) change_LLerval(k*+,l,r);
    e[k].w=(e[k*].w+e[k*+].w)%p;
}

IN void ask_LLerval(LL k,LL l,LL r){
    LL ll=e[k].l,rr=e[k].r,mid=(ll+rr)/;
    if(ll>=l&&rr<=r){
        ans=(e[k].w+ans)%p;return;
    }if(e[k].f!=||e[k].mul!=) down(k);
    if(l<=mid) ask_LLerval(k*,l,r);if(r>mid) ask_LLerval(k*+,l,r);
    e[k].w=(e[k*].w+e[k*+].w)%p;
}

int main()
{
    in(n);in(m);in(p);
    build(,,n);
    while(m--){
        LL tp,x,y,k;
        in(tp);in(x);in(y);
        if(tp!=) in(k);
        if(tp==) X=k,mull(,x,y);
        else if(tp==) X=k,change_LLerval(,x,y);
        else{
            ans=,ask_LLerval(,x,y);
            printf("%d\n",ans);
        }
    }return ;
}

B数据结构

链接：https://www.nowcoder.com/acm/contest/200/B
来源：牛客网

qn姐姐最好了~
qn姐姐给你了一个长度为n的序列还有m次操作让你玩，
1 l r 询问区间[l,r]内的元素和
2 l r 询问区间[l,r]内的元素的平方 和
3 l r x 将区间[l,r]内的每一个元素都乘上x
4 l r x 将区间[l,r]内的每一个元素都加上x

维护区间平方和的值。其他类似吧。。

 

#include<bits/stdc++.h>

#define N int(1e6)
#define LL long long

using namespace std;

void in(LL &x) {
    register char c=getchar();
    x=;
    int f=;
    while(!isdigit(c)) {
        if(c=='-') f=-;
        c=getchar();
    }
    while(isdigit(c)) {
        x=x*+c-'';
        c=getchar();
    }
    x*=f;
}

struct node{
    LL l,r,w1,w2,mul,ad;
}tr[N];

inline void push_up(int k){
    tr[k].w1=tr[k<<].w1+tr[k<<|].w1;
    tr[k].w2=tr[k<<].w2+tr[k<<|].w2;
}

inline void build(LL k,LL l,LL r){
    tr[k].l=l,tr[k].r=r,tr[k].mul=;
    if(l==r) {
        in(tr[k].w1);
        tr[k].w2=tr[k].w1*tr[k].w1;
        return;
    }
    LL mid=(l+r)>>;
    build(k<<,l,mid);
    build(k<<|,mid+,r);
    push_up(k);
}

inline void push_down(LL k){
    tr[k<<].w2=tr[k<<].w2*tr[k].mul*tr[k].mul+tr[k<<].w1**tr[k].ad+(tr[k<<].r-tr[k<<].l+)*tr[k].ad*tr[k].ad;
    tr[k<<].w1=tr[k<<].w1*tr[k].mul+tr[k].ad*(tr[k<<].r-tr[k<<].l+);
    tr[k<<].ad+=tr[k].ad;
    tr[k<<].mul*=tr[k].mul;

    tr[k<<|].w2=tr[k<<|].w2*tr[k].mul*tr[k].mul+tr[k<<|].w1**tr[k].ad+(tr[k<<|].r-tr[k<<|].l+)*tr[k].ad*tr[k].ad;
    tr[k<<|].w1=tr[k<<|].w1*tr[k].mul+tr[k].ad*(tr[k<<|].r-tr[k<<|].l+);
    tr[k<<|].ad+=tr[k].ad;
    tr[k<<|].mul*=tr[k].mul;

    tr[k].ad=,tr[k].mul=;
}

inline void update_mul(LL k,LL L,LL R,LL w){
    int l=tr[k].l,r=tr[k].r,mid=(l+r)>>;
    if(l>=L&&r<=R){
        tr[k].mul*=w;
        tr[k].ad*=w;
        tr[k].w2=w*w*tr[k].w2;
        tr[k].w1=w*tr[k].w1;
        return;
    }
    push_down(k);
    if(L<=mid) update_mul(k<<,L,R,w);
    if(R>mid) update_mul(k<<|,L,R,w);
    push_up(k);
}

inline void update(LL k,LL L,LL R,LL w){
    int l=tr[k].l,r=tr[k].r,mid=(l+r)>>;
    if(l>=L&&r<=R){
        tr[k].w2+=tr[k].w1**w+(r-l+)*w*w;
        tr[k].w1+=w*(r-l+);
        tr[k].ad+=w;
        return;
    }
    push_down(k);
    if(L<=mid) update(k<<,L,R,w);
    if(R>mid) update(k<<|,L,R,w);
    push_up(k);
}

LL query1(LL k,LL L,LL R){
    int l=tr[k].l,r=tr[k].r,mid=(l+r)>>;
    if(l>=L&&r<=R) return tr[k].w1;
    push_down(k);
    LL an=;
    if(L<=mid) an+=query1(k<<,L,R);
    if(R>mid) an+=query1(k<<|,L,R);
    push_up(k);
    return an;
}

LL query2(LL k,LL L,LL R){
    int l=tr[k].l,r=tr[k].r,mid=(l+r)>>;
    if(l>=L&&r<=R) return tr[k].w2;
    push_down(k);
    LL an=;
    if(L<=mid) an+=query2(k<<,L,R);
    if(R>mid) an+=query2(k<<|,L,R);
    push_up(k);
    return an;
}

LL n,m;

int main()
{
    in(n),in(m);
    build(,,n);
    for(LL opt,l,r,w,i=;i<=m;i++){
        in(opt),in(l),in(r);
        if(opt==){
            printf("%lld\n",query1(,l,r));
        }
        if(opt==){
            printf("%lld\n",query2(,l,r));
        }
        if(opt==){
            in(w);
            update_mul(,l,r,w);
        }
        if(opt==){
            in(w);
            update(,l,r,w);
        }
    }
    return ;
}