P3372 【模板】线段树 1

题目描述

如题,已知一个数列,你需要进行下面两种操作:

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

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

输入输出格式

输入格式:

第一行包含两个整数N、M,分别表示该数列数字的个数和操作的总个数。

第二行包含N个用空格分隔的整数,其中第i个数字表示数列第i项的初始值。

接下来M行每行包含3或4个整数,表示一个操作,具体如下:

操作1: 格式:1 x y k 含义:将区间[x,y]内每个数加上k

操作2: 格式:2 x y 含义:输出区间[x,y]内每个数的和

输出格式:

输出包含若干行整数,即为所有操作2的结果。

输入输出样例

输入样例#1: 复制

5 5
1 5 4 2 3
2 2 4
1 2 3 2
2 3 4
1 1 5 1
2 1 4

输出样例#1: 复制

11
8
20

说明

时空限制:1000ms,128M

数据规模:

对于30%的数据:N<=8,M<=10

对于70%的数据:N<=1000,M<=10000

对于100%的数据:N<=100000,M<=100000

(数据已经过加强^_^,保证在int64/long long数据范围内)

样例说明:

题解:来敲一发线段树模板。

针对这样的线段树裸模板,相对而言最难的一部分是懒标记的下放。

懒标记的作用将在线段树模板2中细细谈到。网址链接:http://www.cnblogs.com/zk1431043937/p/7738348.html

建树部分就是直接将区间不断等分建树,树的形状是一棵二叉树。

改变区间值和询问区间值时,从最上面的节点不断向下。直到碰到一些线段,刚好能不多不少覆盖你要询问或修改的区间。

每次修改操作或询问操作是O(log2N)的,且这两步都有可能涉及懒标记下放,具体如下。

首先对于询问操作:

1、若访问到的该区间恰好是你要覆盖到的区间,直接返回该段区间储存的值。

若1条件不满足,则需要将该节点的懒标记向儿子下放,并让儿子区间的值加上该段区间懒标记的值×区间长度,儿子区间懒标记的值加上这段区间懒标记的值,将该区间懒标记清零。

2、若你想覆盖的区间全部在访问到的区间的中间值的左侧,则向左儿子走;若你想覆盖的区间全部在访问到的区间的中间值的右侧,则向右儿子走。

3、若你想覆盖的区间既有一部分在左儿子,又有一部分在右儿子,则向两个儿子一起深搜,最后返回两段儿子区间需要覆盖部分相加后的和。

然后对于修改操作:

1、若访问到的该区间恰好是你要覆盖到的区间,直接修改这段区间的值,并打上懒标记。

若1条件不满足,则需要将该节点的懒标记向儿子下放,并让儿子区间的值加上该段区间懒标记的值×区间长度,儿子区间懒标记的值加上这段区间懒标记的值,将该区间懒标记清零。

2、若你想覆盖的区间全部在访问到的区间的中间值的左侧,则向左儿子走;若你想覆盖的区间全部在访问到的区间的中间值的右侧,则向右儿子走。

3、若你想覆盖的区间既有一部分在左儿子,又有一部分在右儿子,则向两个儿子一起深搜,最后该区间的值等于两段儿子区间值相加后的和。

可以证明,因为线段树覆盖的区间在[1,n]范围内,所以线段树共有log2N层,因此每一次修改或询问操作就是O(log2N)的,因此,修改加询问的总复杂度是O(Mlog2N)的。

由于线段树建树时相当于遍历了整棵树,最多约有2n个节点,因此建树复杂度比修改加询问复杂度要小。

综上,总复杂度约为O(Mlog2N)。

#include<bits/stdc++.h>
using namespace std;
const int N=100005;
struct node{
    int l,r; long long v,lazy;
}a[N<<2];
int n,m,opt,x,y;
long long k;
void build(int u,int l,int r)
{
    a[u].l=l; a[u].r=r;
    if (l==r) scanf("%lld",&a[u].v);
    else
    {
        int mid=(l+r)>>1;
        build(u<<1,l,mid);
        build(u<<1|1,mid+1,r);
        a[u].v=a[u<<1].v+a[u<<1|1].v;
    }
}
void apply(int u,long long v)
{
    a[u].lazy+=v;
    a[u].v+=(a[u].r-a[u].l+1)*v;
}
void push_down(int u)
{
    if (a[u].lazy)
    {
        apply(u<<1,a[u].lazy);
        apply(u<<1|1,a[u].lazy);
        a[u].lazy=0;
    }
}
void change(int u,int l,int r,long long v)
{
    if (a[u].l==l&&a[u].r==r) apply(u,v);
    else
    {
        int mid=(a[u].l+a[u].r)>>1;
        push_down(u);
        if (r<=mid) change(u<<1,l,r,v);
        else if (l>mid) change(u<<1|1,l,r,v);
        else change(u<<1,l,mid,v),change(u<<1|1,mid+1,r,v);
        a[u].v=a[u<<1].v+a[u<<1|1].v;
    }
}
long long query(int u,int l,int r)
{
    if (a[u].l==l&&a[u].r==r) return a[u].v;
    int mid=(a[u].l+a[u].r)>>1;
    push_down(u);
    if (r<=mid) return query(u<<1,l,r);
    else if (l>mid) return query(u<<1|1,l,r);
    return query(u<<1,l,mid)+query(u<<1|1,mid+1,r);
}
int main()
{
    scanf("%d%d",&n,&m);
    build(1,1,n);
    for (int i=1;i<=m;++i)
    {
        scanf("%d",&opt);
        if (opt==1) scanf("%d%d%lld",&x,&y,&k),change(1,x,y,k);
        if (opt==2) scanf("%d%d",&x,&y),printf("%lld\n",query(1,x,y));
    }
    return 0;
}

猜你喜欢

转载自blog.csdn.net/henu111/article/details/81244408