线段树

学前班的鱼同学 - 线段树视频

- 线段树 -

线段树：

线段树（Segment Tree）是一种基于分治思想的二叉树结构，用于在区间上进行信息统计，区间可加减性是它的一个重要性质。与按照二进制位（2的次幂）进行区间划分的树状数组相比，线段树是一种更加通用的结构，树状数组能做的线段树都能做，不过树状数组会更快一些，需要的内存也比线段树小。存储线段树的数组一般要开到题目中数据的四倍大小才能确保够大：
1、线段树的每个节点都代表一个区间；
2、线段树具有唯一的根节点，代表的区间是整个统计范围，如 [1，N]；
3、线段树的每个叶节点都代表一个长度为1的元区间 [x，x]；
4、对于每个内部节点 [l，r]，它的左子节点是 [l，mid]，右子节点是 [mid+1，r]，其中 mid=(l+r)/2 （向下取整）。

一、給定一个长度为n的序列，有两个操作，第一个在区间[l,r]上增加x，第二个询问区间[l,r]的和：

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;

int a[100005];
int d[100005<<2], b[100005<<2];//区间和，lazy标记

inline void pushup(int p) {//标记上传
    d[p]=d[p<<1]+d[(p<<1)|1];//d[p]=d[p*2]+d[p*2+1]
    return ;

inline void pushdown(int s, int t, int p) {//标记下传
    int mid=(s+t)>>1;
    d[p<<1]+=(mid-s+1)*b[p];
    d[(p<<1)|1]+=(t-mid)*b[p];
    b[p<<1]+=b[p];
    b[(p<<1)|1]+=b[p];
    b[p]=0;
}

inline void build(int s, int t, int p) {//建树
    if(s==t) {//若是叶子结点
        d[p]=a[s];//区间和=它本身
        return ;
    }
    int mid=(s+t)>>1;//mid=(s+t)/2区间中点
    build(s, mid, p<<1);//左子节点
    build(mid+1, t, (p<<1)|1);//右子节点
    pushup(p);//更新父节点
}

inline void update(int l, int r, int c, int s, int t, int p) {
    //把区间[l,r]加c，p是点号，s和t是这个点号代表的区间
    if(1<=s && t<=r) {//若是l~r的子区间
        d[p]+=(t-s+1)*c;
        b[p]+=c;//标记
        return ;
    }
    //若没有完全覆盖
    if(b[p]) pushdown(s, t, p);//若有标记，则要即时下传
    int mid=(s+t)>>1;
    if(l<=mid) update(l, r, c, s, mid, p<<1);//左子节点有部分要更新
    if(r>mid) update(l, r, c, mid+1, t, (p<<1)|1);//右子节点有部分要更新
    pushup(p);//更新父节点
}

inline int getans(int l, int r, int s, int t, int p) {
    //查询[l,r]，p是节点，s和t是这个节点对应的区间
    int ans=0;
    if(l<=s && t<=r) {//完全包含
        return d[p];
    }
    //否则访问子节点
    if(b[p]) pushdown(s, t, p);
    int mid=(s+t)>>1;
    if(l<=mid) ans+=getans(l, r, s, mid, p<<1);//如果在左边
    if(r>mid) ans+=getans(l, r, mid+1, t, (p<<1)|1);
    return ans;
}

int main() {
    int n, m;//n是区间长度，m是操作个数
    scanf("%d %d", &n, &m);
    for(register int i=1; i<=n; i++) scanf("%d", &a[i]);//输入a[i]
    build(1, n, 1);//开始建树
    for(register int i=1; i<=m; i++) {
        int opt=0;//操作
        scanf("%d", &opt);
        if(opt==1) {//在区间[l,r]上增加c
            int l, r, c;
            scanf("%d %d %d", &l, &r, &c);
            update(l, r, c, 1, n, 1);//更新区间， 增加值，区间，节点
        }
        if(opt==2) {//询问区间[l,r]的和
            int l, r;
            scanf("%d %d", &l, &r);
            printf("%d\n", getans(l, r, 1, n, 1));//求和并输出结果
        }
    }
    return 0;
}

二、给定一个长度为n的序列，一开始全是0，有两个操作，一个是将[l,r]全改成c，一个是询问[l,r]不同的数字个数：（考虑边界）

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;

int a[100005<<2], num[100005<<2], b[100005<<2], pre[100005<<2], las[100005<<2];
//数组，区间不同的颜色（数字）个数，lazy标记，区间前面的数，区间后面的数

inline void pushup(int p) {//标记上传
    if(las[p<<1]==pre[(p<<1)|1]) num[p]=num[p<<1]+num[(p<<1)|1]-1;
    //若左子节点后面=右子节点前面，则不同颜色数为左右子节点之和减一
    else num[p]=num[p<<1]+num[(p<<1)|1];//否则
    pre[p]=pre[p<<1];
    las[p]=las[(p<<1)|1];
}

inline void pushdown(int s, int t, int p) {//标记下传
    int mid=(s+t)>>1;
    num[p<<1]=1;
    num[(p<<1)|1]=1;
    pre[p<<1]=pre[p];
    las[p<<1]=las[p];
    pre[(p<<1)|1]=pre[p];
    las[(p<<1)|1]=las[p];
    b[p<<1]=b[p];
    b[(p<<1)|1]=b[p];
    b[p]=0;
}

inline void build(int s, int t, int p) {//建树
    if(s==t) {//若是叶子节点
        num[p]=1;
        pre[p]=0;
        las[p]=0;
        return ;
    }
    int mid=(s+t)>>1;
    build(s, mid, p<<1);
    build(mid+1, t, (p<<1)|1);
    pushup(p);
}

inline void update(int l, int r, int c, int s, int t, int p) {//更新区间[l,r]的信息
    if(l<=s && t<=r) {
        num[p]=1;
        las[p]=pre[p]=c;
        b[p]=c;
        return ;
    }
    if(b[p]) pushdown(s, t, p);
    int mid=(s+t)>>1;
    if(l<=mid) update(l, r, c, s, mid, p<<1);
    if(r>mid) update(l, r, c, mid+1, t, (p<<1)|1);
    pushup(p);
}

inline int getans(int l, int r, int s, int t, int p) {
    if(l<=s && t<=r) {
        return num[p];
    }
    if(b[p]) pushdown(s, t, p);
    int mid=(s+t)>>1;
    int ans=0;
    if(l<=mid) ans+=getans(l, r, s, mid, p<<1);
    if(r>mid) ans+=getans(l, r, mid+1, t, (p<<1)|1);
    if(las[p<<1]==pre[(p<<1)|1]) ans--;
    return ans;
}

int main() {
    int n, m;
    scanf("%d %d", &n, &m);
    build(1, n, 1);
    for(register int i=1; i<=m; i++) {
        int opt, l, r;
        scanf("%d", &opt);
        if(opt==0) {
            int c;
            c=0;
            scanf("%d %d %d", &l, &r, &c);
            update(l, r, c, 1, n, 1);
        }
        if(opt==1) {
            scanf("%d %d", &l, &r);
            printf("%d\n", getans(l, r, 1, n, 1));//求区间不同数字的个数并输出答案
        }
    }
    return 0;
}

三、给定一个长度为n的序列，询问[l,r]的最大子段和：
*最大子段和：[l,r]的最大子段和为存在一个区间[x,y]属于[l,r]满足对于任意属于[l,r]满足sum(i,j)<=sum(x,y)

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;

template<typename sp>
inline void qread(sp &x) {
    char ch=getchar(), lst=' ';
    while(ch<'0' || ch>'9') lst=ch, ch=getchar();
    while(ch>='0' && ch<='9') x=(x<<3)+(x<<1)+(ch^48), ch=getchar();
    if(lst=='-') x=-x;
}

template<typename sp>
sp mmax(sp a, sp b) {
    return a>b ? a : b;
}

int a[100005];
struct Node{
    int ans, pre, las, sum;//最大子段和，区间左边部分的和，区间右边部分的和，整个区间的和
}d[100005<<2];

inline void pushup(int p) {//上传数据更新
    d[p].ans=mmax(mmax(d[p<<1].ans, d[(p<<1)|1].ans), d[(p<<1)|1].pre+d[p<<1].las);
    d[p].pre=mmax(d[p<<1].pre, d[p<<1].sum+d[(p<<1)|1].pre);
    d[p].las=mmax(d[(p<<1)|1].las, d[(p<<1)|1].sum+d[p<<1].las);
    d[p].sum=d[p<<1].sum+d[(p<<1)|1].sum;
}

inline void build(int s, int t, int p) {//建树
    if(s==t) {
        d[p].ans=a[s];
        d[p].pre=a[s];
        d[p].las=a[s];
        d[p].sum=a[s];
        return ;
    }
    int mid=(s+t)>>1;
    build(s, mid, p<<1);
    build(mid+1, t, (p<<1)|1);
    pushup(p);
}

inline Node getans(int l, int r, int s, int t, int p) {//区间查询
    if(l<=s && t<=r) return d[p];
    int mid=(s+t)>>1;
    if(r<=mid) return getans(l, r, s, mid, p<<1);
    else if(l>mid) return getans(l, r, mid+1, t, (p<<1)|1);
    else {
        Node ans;
        Node lans=getans(l, r, s, mid, p<<1), rans=getans(l, r, mid+1, t, (p<<1)|1);
        ans.pre=mmax(lans.pre, lans.sum+rans.pre);
        ans.las=mmax(rans.las, rans.sum+lans.las);
        ans.ans=mmax(mmax(rans.ans, lans.ans), lans.las+rans.pre);
        return ans;
    }
}

int main() {
    int n, m;
    qread(n); qread(m);
    for(register int i=1; i<=n; i++) qread(a[i]);
    build(1, n, 1);
    for(register int i=1; i<=n; i++) {
        int l, r;
        qread(l); qread(r);
        printf("%d\n", getans(l, r, 1, n, 1).ans);
    }
    return 0;
}