线段树

查询给定区间的最值

每次查询复杂度O(1) 

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int MAX_N = 100010;
int minn[4 * MAX_N];
int ans[MAX_N];
int n,m;
inline void build(int i , int l ,int r){
    if(l == r){
        minn[i] = ans[l];
        return ;
    }
    int mid = (l + r) >> 1;
    build(i * 2, l, mid);
    build(i * 2 + 1,mid + 1, r);
    minn[i] = max(minn[i * 2] , minn[i * 2 + 1]);
}
inline int Query(int k, int a, int b, int l, int r){
    if(b < l || a > r) return 0;
    if(a <= l && r <= b) return minn[k];
    int mid = (l + r) >> 1;
    return max(Query(k * 2, a,b,l, mid), Query(k * 2 + 1, a, b, mid + 1,r));
}
int main(){
    cin >> n >> m;
    for(int i = 1;i <= n; i++){
        scanf("%d",&ans[i]);
    }
    build(1,1,n);
    while(m--){
        int x,y;
        scanf("%d%d",&x,&y);
        printf("%d\n",Query(1,x,y,1,n));
    }
    return 0;
}

再来个区间修改，区间查询的：线段树1，首先介绍下lazy标记：

懒惰（Lazy）标记

懒惰标记，也可称为延迟标记。一个区间可以转化为若干个结点，每个结点设一个标记，记录这个结点被进行了某种修改操作（这种修改操作会影响其子结点）。

也就是说，仅修改到这些结点，暂不修改其子结点；而后决定访问其子节点时，再下传懒惰 (Lazy) 标记，并消除原来的标记。优点在于，不用将区间的所有值暴力更新，大大提高效率。

在区间修改的一类问题中，我们可以设一个 delta 域，表示该节点需要加上数值 delta。由于该节点表示的是一个区间，向下访问时，子节点的 delta 需要加上该节点的 delta，同时该节点的 delta 变为 0。访问叶子节点时，再对该元素的数值加上 delta 即可。

同理，在区间更新（赋值）的一类问题，我们可以设一个 color 域，表示该节点（区间）都被数值 color 覆盖。向下访问时，子节点的 color 更新成该节点的 color，同时该节点的 color 变为 0。访问叶子节点时，再将该元素修改成 color 即可。

直接看代码：

#include<iostream>
#include<cstdio>
using namespace std;
long long color[400005] = {0};
long long s[400005] = {0};
long long ss[100005] = {0};
void Down(int i, int l,int r){
    if(color[i]){
        int mid = (l + r) >> 1;
        s[i * 2] += color[i] * (mid - l + 1);
        s[i * 2 + 1] += color[i] * (r - mid);
        color[i * 2] += color[i];
        color[i * 2 + 1] += color[i];
        color[i] = 0;
    }
}

void Modify(int i, int a, int b, int l ,int r, int x){
    if(l >= a && r <= b){
        s[i] += (r - l + 1) * x;
        color[i] += x;
        return ;
    }
    Down(i,l,r);
    int mid = (l + r) >> 1;
    if(a <= mid) Modify(i * 2, a, b, l ,mid , x);
    if(b > mid) Modify(i * 2 + 1, a, b, mid + 1, r, x);
    s[i] = s[i * 2] + s[i * 2 + 1];
}
void build(int i , int l ,int r){
    color[i] = 0;
    if(l == r){
        s[i] = ss[l];
        return ;
    }
    int mid = (l + r) >> 1;
    build(i * 2, l, mid);
    build(i * 2 + 1,mid + 1, r);
    s[i] = s[i * 2] + s[i * 2 + 1];
}
long long Query(int i , int a, int b, int l ,int r){
    if(l >= a && r <= b){
        return s[i];
    }
    Down(i,l,r);
    int mid = (l + r) >> 1;
    long long res = 0;
    if(a <= mid)res += Query(i * 2,a,b, l ,mid);
    if(b > mid) res += Query(i * 2 + 1,a,b,mid + 1,r);
    return res;
}

int main(){
    int n, m, k;
    cin >> n >> m;
    for(int i = 1;i <= n; i++){
        scanf("%lld",&ss[i]);
    }
    build(1,1,n);
    while(m--){
        int a,b,x,c,d;
        scanf("%d",&k);
        if(k == 1){
            scanf("%d%d%d",&a,&b,&x);
            Modify(1, a,b,1,n,x);
        }
        if(k == 2){
            scanf("%d%d",&c,&d);
            printf("%lld\n",Query(1,c,d,1,n));
        }
    }
    return 0;
}

下面来点有意思的：线段树2

题目需要我们给连续区间加一个数，这很容易想到lazy标记，可是又有一种区间乘上一个数的操作，

这就很毒瘤了，我们需要用到两个lazy标记，而且最后要将标记下传所得到的值合并。

线段树的核心思想即优化区间修改的复杂度（只修改存放区间和的节点值，并打上标记），

区间查询的复杂度为logn（二叉树的性质）。

下面看代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#define N 400003
#define LL long long 
using namespace std;
int n,m,a[N];
LL tr[N],add[N],mul[N],p;
void update(int x)
{
    tr[x]=(tr[x<<1]+tr[x<<1|1])%p;
}
void build(int now,int l,int r)
{
    mul[now]=1; add[now]=0;//赋乘法和加法的初值 
    if (l==r) {
        tr[now]=a[l]; 
		mul[now]=1;//乘法树初始化为1 
        return;
    }
    int mid=(l+r) >> 1;
    build(now<<1,l,mid);
    build(now<<1|1,mid+1,r);
    update(now);
}
void pushdown(int now,int l,int r)
{
    int mid=(l+r)>>1;
    if (mul[now]!=1) {//如果有标记 
    	//下传标记 
        tr[now<<1]=tr[now<<1]*mul[now]%p;
        tr[now<<1|1]=tr[now<<1|1]*mul[now]%p;
        mul[now<<1]=mul[now<<1]*mul[now]%p;
        mul[now<<1|1]=mul[now<<1|1]*mul[now]%p;
        add[now<<1]=add[now<<1]*mul[now]%p;
        add[now<<1|1]=add[now<<1|1]*mul[now]%p;
        mul[now]=1;//清除标记，防止对下次操作产生影响 
    }
    if (add[now]) {//如果有标记
		//下传标记 
        tr[now<<1]+=add[now]*(mid-l+1)%p;
        if (tr[now]>=p) tr[now]-=p;
        tr[now<<1|1]+=add[now]*(r-mid)%p;
        if (tr[now]>=p) tr[now]-=p;
        add[now<<1]+=add[now];
        if (add[now]>=p) add[now]-=p;
        add[now<<1|1]+=add[now]; 
        if (add[now]>=p) add[now]-=p;
        add[now]=0;//清除标记，防止对下次操作产生影响
    }
}
void qjmul(int now,int l,int r,int ll,int rr,LL val)
{
    if (ll<=l&&r<=rr) {
        tr[now]=tr[now]*val%p;
        mul[now]=mul[now]*val%p;
        add[now]=add[now]*val%p;
        return;
    }
    int mid=(l+r)/2;
    pushdown(now,l,r);
    if (ll<=mid) qjmul(now<<1,l,mid,ll,rr,val);
    if (rr>mid) qjmul(now<<1|1,mid+1,r,ll,rr,val);
    update(now);
}
void qjadd(int now,int l,int r,int ll,int rr,LL val)
{
    if (ll<=l&&r<=rr) {
        tr[now]=(LL)(tr[now]+(LL)(r-l+1)*val%p);
        if (tr[now]>=p) tr[now]-=p;
        add[now]+=val;
        if (add[now]>=p) add[now]-=p;
        return;
    }
    int mid=(l+r)/2;
    pushdown(now,l,r);
    if (ll<=mid) qjadd(now<<1,l,mid,ll,rr,val);
    if (rr>mid) qjadd(now<<1|1,mid+1,r,ll,rr,val);
    update(now);
}
LL qjsum(int now,int l,int r,int ll,int rr)
{
    if (ll<=l&&r<=rr) return tr[now];
    int mid=(l+r)/2; LL ans=0;
    pushdown(now,l,r);
    if (ll<=mid) ans+=qjsum(now<<1,l,mid,ll,rr); ans%=p;
    if (rr>mid) ans+=qjsum(now<<1|1,mid+1,r,ll,rr); ans%=p;
    return ans;
}
int main()
{
    scanf("%d%d%lld",&n,&m,&p);
    for (int i=1;i<=n;i++) scanf("%d",&a[i]);
    build(1,1,n);
    for (int i=1;i<=m;i++) {
        int opt,x,y,z;
        scanf("%d%d%d",&opt,&x,&y);
        if (opt==2) {
            scanf("%d",&z);
            qjadd(1,1,n,x,y,z);
        }
        if (opt==1) {
            scanf("%d",&z);
            qjmul(1,1,n,x,y,z);
        }
        if (opt==3) {
            printf("%lld\n",qjsum(1,1,n,x,y)%p);
        }
    }
}

这样是不是对线段树更深入的理解了，加油！