线段树维护区间子段和（模板题）

最新推荐文章于 2024-08-21 19:41:42 发布

RevolIA

最新推荐文章于 2024-08-21 19:41:42 发布

阅读量537

点赞数 1

分类专栏：模板类（什么、这也是模板）思维（抖啊、抖啊、抖个机灵儿）

本文链接：https://blog.csdn.net/Du_Mingm/article/details/98938567

版权

思维（抖啊、抖啊、抖个机灵儿）同时被 2 个专栏收录

134 篇文章 1 订阅

订阅专栏

模板类（什么、这也是模板）

108 篇文章 3 订阅

订阅专栏

题目链接、

题意：

给定长度为N的数列A，以及M条指令，每条指令可能是以下两种之一：

1、“1 x y”，查询区间 [x,y] 中的最大连续子段和，即 $max_{x\leq l\leq r\leq y }\{\sum_{i=l}^{r}A[i] \}$

2、“2 x y”，把 A[x] 改成 y

对于每个查询指令，输出一个整数表示答案。

题解：

线段树维护

一、线段树的精髓——区间合并，考虑怎么合并就行了：

1、合并的答案要么左区间的子段和，要么是右区间的子段和，要么是中间的一部分

2、考虑中间这部分怎么求，也就是说，其实求一个区间的最大，前后缀就行了，因为中间这部分就是

左区间的最大后缀+右区间的最大前缀

3、考虑怎么维护区间的前后缀、前缀的话，肯定是左区间前缀 和 左区间的区间和 加 右区间的前缀 取一个最大值

后缀同理
二、区间查询

这里和一般的线段树查询不太一样的（确切的说和我之前的板子不太一样）

因为并不能直接区间做加法，返回的结构体嘛

对于查询区间全部包含当前区间时，直接返回结构体即可

否则，在右边往右查，在左边往左查

剩下的就是跨越左右子区间了，那么，返回 合并的左右查询的结构体 就行了

提供另一种查询方式：

对于查询的，如果正好是节点的，直接返回

否则，在右边往右查，在左边往左查

剩下跨区间的，查询和，然后合并返回

这里相当于将查询的给分解成了，线段树上的点
node query(int l,int r,int L = 1,int R = n,int k = 1){
    if(l == L && R == r)return tree[k];
    int mid = L+R>>1;
    if(r<=mid)return query(l,r,L,mid,k<<1);
    if(l>mid)return query(l,r,mid+1,R,k<<1|1);
    node x = query(l,mid,L,mid,k<<1);
    node y = query(mid+1,r,mid+1,R,k<<1|1);
    node Ans;
    Ans.sum = x.sum+y.sum;
    Ans.lsum = max(x.lsum,x.sum+y.lsum);
    Ans.rsum = max(y.rsum,y.sum+x.rsum);
    Ans.Ans = max(max(x.Ans,y.Ans),x.rsum+y.lsum);
    return Ans;
}

/*author:revolIA*/
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 5e5+7,inf = 0x3f3f3f3f;
ll n,m,opt,l,r;
struct node{
    ll lsum,rsum,sum,Ans;
    void update(ll x){
        lsum = x;
        rsum = x;
        sum = x;
        Ans = x;
    }
}tree[maxn<<2];
void push_up(int x){
    tree[x].sum = tree[x<<1].sum+tree[x<<1|1].sum;
    tree[x].lsum = max(tree[x<<1].lsum,tree[x<<1].sum+tree[x<<1|1].lsum);
    tree[x].rsum = max(tree[x<<1|1].rsum,tree[x<<1|1].sum+tree[x<<1].rsum);
    tree[x].Ans = max(max(tree[x<<1].Ans,tree[x<<1|1].Ans),tree[x<<1].rsum+tree[x<<1|1].lsum);
}
void build(int L = 1,int R = n,int x = 1){
    tree[x].lsum = tree[x].rsum = 0;
    tree[x].sum = tree[x].Ans = 0;
    if(L == R){
        scanf("%lld",&tree[x].sum);
        tree[x].lsum = tree[x].rsum = tree[x].Ans = tree[x].sum;
        return;
    }
    int mid = L+R>>1;
    build(L,mid,x<<1),build(mid+1,R,x<<1|1);
    push_up(x);
}
void update(int k,ll val,int L=1,int R=n,int x = 1){
    if(L == R){
        tree[x].update(val);
    }else{
        int mid = L+R>>1;
        if(k<=mid)update(k,val,L,mid,x<<1);
        else update(k,val,mid+1,R,x<<1|1);
        push_up(x);
    }
}
node query(int l,int r,int L = 1,int R = n,int k = 1){
    if(l <= L && R <= r)return tree[k];
    int mid = L+R>>1;
    if(l>mid)return query(l,r,mid+1,R,k<<1|1);
    if(r<=mid)return query(l,r,L,mid,k<<1);
    node x = query(l,r,L,mid,k<<1);
    node y = query(l,r,mid+1,R,k<<1|1);
    node Ans;
    Ans.sum = x.sum+y.sum;
    Ans.lsum = max(x.lsum,x.sum+y.lsum);
    Ans.rsum = max(y.rsum,y.sum+x.rsum);
    Ans.Ans = max(max(x.Ans,y.Ans),x.rsum+y.lsum);
    return Ans;
}
int main(){
    scanf("%lld%lld",&n,&m);
    build();
    while(m--){
        scanf("%lld%lld%lld",&opt,&l,&r);
        if(opt == 1){
            if(l>r)swap(l,r);
            printf("%lld\n",query(l,r).Ans);
        }
        else update(l,r);
    }
    return 0;
}

注意到，合并区间这个操作，在查询和push_up的时候都用到了，所以，我觉得单独提出来作为一个函数比较好

所以、

/*author:revolIA*/
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 5e5+7,inf = 0x3f3f3f3f;
ll n,m,opt,l,r;
struct node{
    ll lsum,rsum,sum,Ans;
    void update(ll x){
       Ans = sum = rsum = lsum = x;
    }
}tree[maxn<<2];
node Merge(node B,node C,node A = node{0,0,0,0}){
    A.sum = B.sum+C.sum;
    A.lsum = max(B.lsum,B.sum+C.lsum);
    A.rsum = max(C.rsum,C.sum+B.rsum);
    A.Ans = max(max(B.Ans,C.Ans),B.rsum+C.lsum);
    return A;
}
void build(int L = 1,int R = n,int x = 1){
    tree[x].lsum = tree[x].rsum = 0;
    tree[x].sum = tree[x].Ans = 0;
    if(L == R){
        scanf("%lld",&tree[x].sum);
        tree[x].lsum = tree[x].rsum = tree[x].Ans = tree[x].sum;
        return;
    }
    int mid = L+R>>1;
    build(L,mid,x<<1),build(mid+1,R,x<<1|1);
    tree[x]=Merge(tree[x<<1],tree[x<<1|1]);
}
void update(int k,ll val,int L=1,int R=n,int x = 1){
    if(L == R){
        tree[x].update(val);
    }else{
        int mid = L+R>>1;
        if(k<=mid)update(k,val,L,mid,x<<1);
        else update(k,val,mid+1,R,x<<1|1);
        tree[x]=Merge(tree[x<<1],tree[x<<1|1]);
    }
}
node query(int l,int r,int L = 1,int R = n,int k = 1){
    if(l == L && R == r)return tree[k];
    int mid = L+R>>1;
    if(l>mid)return query(l,r,mid+1,R,k<<1|1);
    if(r<=mid)return query(l,r,L,mid,k<<1);
    return Merge(query(l,mid,L,mid,k<<1),query(mid+1,r,mid+1,R,k<<1|1));
}
int main(){
    scanf("%lld%lld",&n,&m);
    build();
    while(m--){
        scanf("%lld%lld%lld",&opt,&l,&r);
        if(opt == 1){
            if(l>r)swap(l,r);
            printf("%lld\n",query(l,r).Ans);
        }
        else update(l,r);
    }
    return 0;
}