线段树（从入门到入土）

题目描述

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

1. 将某区间每一个数加上 kkk。
2. 求出某区间每一个数的和。

输入格式

第一行包含两个整数 n,mn, mn,m，分别表示该数列数字的个数和操作的总个数。

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

接下来 mmm 行每行包含 333 或 444 个整数，表示一个操作，具体如下：

1. 1 x y k：将区间 [x,y][x, y][x,y] 内每个数加上 kkk。
2. 2 x y：输出区间 [x,y][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

---

什么是线段树

线段树是二叉树的一种，把一个数组（也就是线段）不停二分至每个叶子节点存一个数。

例如 父亲节点存 下标1-4的和 那么两个子节点分别存下标 1-3 和 4-5 的和。

怎么用数组表示二叉树就8解释了。

---

建树

先写结构体

struct node {
    int l,r;
    long long sum,lz;
}tree[900000];

l,r分别存左右子树下标，sum存一段数组的和，lz作为标记  后面解释捏

根据二叉树性质父亲节点 i 的两个子节点分别是 i*2 和 i*2+1

叶子节点的两个子节点相同

可得

void buildtree(int a,int l,int r)
{
    tree[a].l=l;
    tree[a].r=r;
    if(l==r)
    {
        tree[a].sum=x[l];
        return;
    }
    int mid=(l+r)>>1;
    buildtree(a*2,l,mid);
    buildtree(a*2+1,mid+1,r);
    tree[a].sum=tree[a*2].sum+tree[a*2+1].sum;
}

---

区间修改

判断子树是否在区间内，是就更改sum并且标记，不是就继续递归查找

void add(int a,int l,int r,int k)
{

    if(tree[a].l>=l&&tree[a].r<=r)
    {
        tree[a].sum+=k*(tree[a].r-tree[a].l+1);
        tree[a].lz+=k;
        return;
    }
    push_down(a);
    if(tree[a*2].r>=l)
    {
        add(a*2,l,r,k);
    }
    if(tree[a*2+1].l<=r)
    {
        add(a*2+1,l,r,k);
    }
    tree[a].sum=tree[a*2].sum+tree[a*2+1].sum;

}

---

pushdown（下传标记）

把标记传给子树并更新子树，线段树的核心之一（建议有事没事都加这句）

（因为少加这句AW的好多次

void push_down(int x)
{
    if(tree[x].l==tree[x].r)
    {
        return;
    }
    if(tree[x].lz!=0)
    {

        tree[x*2].sum+=tree[x].lz*(tree[x*2].r-tree[x*2].l+1);
        tree[x*2].lz+=tree[x].lz;
        tree[x*2+1].sum+=tree[x].lz*(tree[x*2+1].r-tree[x*2+1].l+1);
        tree[x*2+1].lz+=tree[x].lz;
        tree[x].lz=0;
    }
}

 

---

区间查找

和更新区间一样判断子树是否在区间范围内。

单点查找和区间查找一样就不写了（什么懒狗）

long long search(int a,int l,int r)
{
    if(tree[a].l>=l&&tree[a].r<=r)
    {
        return tree[a].sum;
    }
    if(tree[a].l>r||tree[a].r<l)return 0;
    push_down(a);

    long long ans=0;
    if(tree[a*2].r>=l)
    {
        ans+= search(a*2,l,r);
    }
    if(tree[2*a+1].l<=r)
    {
        ans+= search(a*2+1,l,r);
    }
    return ans;


}

---

AC代码

#include "bits/stdc++.h"
#define ll long long;
using namespace std;


long long n,m,x[900000];
void push_down(int x);
struct node {
    int l,r;
    long long sum,lz;
}tree[900000];
void buildtree(int a,int l,int r);
void add(int a,int l,int r,int k);
long long query(int a,int x);
long long search(int a,int l,int r);

int main()
{
    ios::sync_with_stdio(0);cin.tie(NULL);cout.tie(NULL);
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        cin>>x[i];
    }
    buildtree(1,1,n);
    long long a,x,y,k;
    for (int i = 1; i <= m; ++i) {
        cin>>a;
        if(a==1)
        {
            cin>>x>>y>>k;
            add(1,x,y,k);
        }else{
            cin>>x>>y;
            cout<<search(1,x,y)<<endl;
        }
    }




}

void push_down(int x)
{
    if(tree[x].l==tree[x].r)
    {
        return;
    }
    if(tree[x].lz!=0)
    {

        tree[x*2].sum+=tree[x].lz*(tree[x*2].r-tree[x*2].l+1);
        tree[x*2].lz+=tree[x].lz;
        tree[x*2+1].sum+=tree[x].lz*(tree[x*2+1].r-tree[x*2+1].l+1);
        tree[x*2+1].lz+=tree[x].lz;
        tree[x].lz=0;
    }
}
void buildtree(int a,int l,int r)
{
    tree[a].l=l;
    tree[a].r=r;
    if(l==r)
    {
        tree[a].sum=x[l];
        return;
    }
    int mid=(l+r)>>1;
    buildtree(a*2,l,mid);
    buildtree(a*2+1,mid+1,r);
    tree[a].sum=tree[a*2].sum+tree[a*2+1].sum;
}
void add(int a,int l,int r,int k)
{

    if(tree[a].l>=l&&tree[a].r<=r)
    {
        tree[a].sum+=k*(tree[a].r-tree[a].l+1);
        tree[a].lz+=k;
        return;
    }
    push_down(a);
    if(tree[a*2].r>=l)
    {
        add(a*2,l,r,k);
    }
    if(tree[a*2+1].l<=r)
    {
        add(a*2+1,l,r,k);
    }
    tree[a].sum=tree[a*2].sum+tree[a*2+1].sum;

}
long long query(int a,int x)
{
    if(tree[a].l==tree[a].r)
    {
        return tree[a].sum;
    }
    push_down(a);
    if(tree[a*2].r>=x)
    {
        return query(a*2,x);
    }else{
        return query(a*2+1,x);
    }
}
long long search(int a,int l,int r)
{
    if(tree[a].l>=l&&tree[a].r<=r)
    {
        return tree[a].sum;
    }
    if(tree[a].l>r||tree[a].r<l)return 0;
    push_down(a);

    long long ans=0;
    if(tree[a*2].r>=l)
    {
        ans+= search(a*2,l,r);
    }
    if(tree[2*a+1].l<=r)
    {
        ans+= search(a*2+1,l,r);
    }
    return ans;


}

---

优化

可以用

inline int lc(int i)return i<<1;
inline int rc(int i)return i<<1|1;

代替 i*2 和 i*2+1 查找左右儿子（