线段树维护连续区间最大子段和

最新推荐文章于 2022-03-11 18:15:33 发布
最新推荐文章于 2022-03-11 18:15:33 发布
阅读量592 收藏
点赞数 1
分类专栏： 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41021816/article/details/98941020
版权

一、线段树维护连续区间最大子段和之单点更新   

             

Snowy Smile

题意：

给你n个点（小于等于2e3个），每个点有个价值val，有个x，y坐标（这三个值都是1e9的）

让你求一个最大的子矩阵和

题解：

线段树的精髓——区间合并

因为x，y太大，所以先考虑离散化，之后是一个n*m的矩形

枚举上，下边界，线段树维护区间最大子段和

 

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

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

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

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

后缀同理

 

详细区间线段树维护 看博客

为了简单起便，只需要查询的是整个区间[1,n]所有，连询问函数也不用写了，直接找根节点的值就行了

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 1e4+7;
int T,n;
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)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);
    }
}

vector<int> vecL,vecU;
vector<pair<int,ll> > vec[maxn];
ll x[maxn],y[maxn],val[maxn];
int main()
{
    for(scanf("%d",&T); T--;)
    {
        vecL.clear();
        vecU.clear();
        for(int i=1; i<=n; i++)vec[i].clear();
        
        scanf("%d",&n);
        for(int i=1; i<=n; i++)
        {
            scanf("%lld%lld%lld",&x[i],&y[i],&val[i]);
            vecL.push_back(x[i]);
            vecU.push_back(y[i]);
        }
        sort(vecL.begin(),vecL.end());
        vecL.erase(unique(vecL.begin(),vecL.end()),vecL.end());
        sort(vecU.begin(),vecU.end());
        vecU.erase(unique(vecU.begin(),vecU.end()),vecU.end());
        for(int i=1; i<=n; i++)
        {
            int x_ = lower_bound(vecL.begin(),vecL.end(),x[i])-vecL.begin()+1;//+1表示从1-n
            int y_ = lower_bound(vecU.begin(),vecU.end(),y[i])-vecU.begin()+1;
            vec[x_].push_back(make_pair(y_,val[i]));
        }
        ll ans = 0;
        for(int i=1; i<=n; i++)
        {
            build();
            for(int j=i; j<=n; j++)
            {
                for(auto k:vec[j])update(k.first,k.second);
                ans = max(ans,tree[1].Ans);//直接找根节点
            }
        }
        printf("%lld\n",ans);
    }
    return 0;
}

二、线段树维护连续区间最大子段和之区间查询       

 

                

GSS1 - Can you answer these queries I

题意：

给定一序列，每次给定区间l，y查询该区间最大连续子段和

题解：

还是线段树维护连续区间最大子段和，这次是区间查询

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 1e4+7;
int T,n,m;
int a[maxn];
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)
{
    if(L == R)
    {
        tree[x].lsum = tree[x].rsum = a[L];
        tree[x].sum = tree[x].Ans = a[L];
        return;
    }
    int mid = L+R>>1;
    build(L,mid,x<<1),build(mid+1,R,x<<1|1);
    push_up(x);
}
node query(int l,int r,int L = 1,int R = n,int x = 1)
{
    if (l <= L && R <= r)return tree[x];
    int mid=(L+R)>>1;
    if (r <= mid) return query(l, r, L, mid, x<<1);
    if (mid < l) return query(l, r, mid+1 , R, x<<1|1);
    node lo = query(l,r,L,mid,x<<1), ro = query(l,r,mid+1,R,x<<1|1),ans;
    ans.sum=lo.sum+ro.sum;
    ans.lsum=max(lo.lsum,lo.sum+ro.lsum);
    ans.rsum=max(ro.rsum,ro.sum+lo.rsum);
    ans.Ans=max(max(lo.Ans,ro.Ans),lo.rsum+ro.lsum);
    return ans;
}
int main()
{
    scanf("%d",&n);
    for(int i=1; i<=n; i++)scanf("%d",&a[i]);
    build();
    scanf("%d",&m);
    while(m--)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        printf("%d\n", query(x, y).Ans);
    }
    return 0;
}

三、线段树维护连续区间最大子段和之单点修改+区间查询        

 

                   

你能回答这些问题吗

题意：

给定长度为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

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

题解：

还是线段树维护

这次是上面两个结合版本

对于区间查询需要注意

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

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

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

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

模板一

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 5e5+7;
int T,n,m;
ll a[maxn];
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)
{
    if(L == R)
    {
        tree[x].lsum = tree[x].rsum = a[L] = tree[x].sum = tree[x].Ans = a[L];
        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 x = 1)
{
    if (l <= L && R <= r)return tree[x];
    int mid=(L+R)>>1;
    if (r <= mid) return query(l, r, L, mid, x<<1);
    if (mid < l) return query(l, r, mid+1 , R, x<<1|1);
    node lo = query(l,r,L,mid,x<<1), ro = query(l,r,mid+1,R,x<<1|1),ans;
    ans.sum=lo.sum+ro.sum;
    ans.lsum=max(lo.lsum,lo.sum+ro.lsum);
    ans.rsum=max(ro.rsum,ro.sum+lo.rsum);
    ans.Ans=max(max(lo.Ans,ro.Ans),lo.rsum+ro.lsum);
    return ans;
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1; i<=n; i++)scanf("%lld",&a[i]);
    build();
    while(m--)
    {
        int k,x,y;
        scanf("%d%d%d",&k,&x,&y);
        if(k==1)
        {
            if(x>y)swap(x,y);
            printf("%lld\n", query(x,y).Ans);
        }
        else update(x,y);
    }
    return 0;
}

模板二

/*
线段树维护区间最大子段和
https://www.acwing.com/problem/content/description/246/
*/
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 5e5+7;
int T,n,m;
ll a[maxn];
struct node
{
    ll lsum,rsum,sum,Ans;
    int l,r;
    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,int r,int x)
{
    tree[x].l=l;
    tree[x].r=r;
    if(l == r)
    {
        tree[x].lsum = tree[x].rsum = tree[x].sum = tree[x].Ans = a[l];
        return;
    }
    int mid = l+r>>1;
    build(l,mid,x<<1),build(mid+1,r,x<<1|1);
    push_up(x);
}
void update(int x,int k,ll val)
{
    int l=tree[x].l;
    int r=tree[x].r;
    if(l == r)
    {
        tree[x].update(val);
        return ;
    }
    else
    {
        int mid = l+r>>1;
        if(k<=mid)update(x<<1,k,val);
        else update(x<<1|1,k,val);
        push_up(x);
    }
}
node query(int x,int l,int r)
{
    int L=tree[x].l;
    int R=tree[x].r;
    if(l<=L && R<=r)return tree[x];
    int mid=(L+R)>>1;
    if (r<=mid) return query(x<<1,l,r);
    if (l>mid) return query(x<<1|1,l,r);
    node lo = query(x<<1,l,r), ro = query(x<<1|1,l,r),ans;
    ans.sum=lo.sum+ro.sum;
    ans.lsum=max(lo.lsum,lo.sum+ro.lsum);
    ans.rsum=max(ro.rsum,ro.sum+lo.rsum);
    ans.Ans=max(max(lo.Ans,ro.Ans),lo.rsum+ro.lsum);
    return ans;
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1; i<=n; i++)scanf("%lld",&a[i]);
    build(1,n,1);
    while(m--)
    {
        int k,x,y;
        scanf("%d%d%d",&k,&x,&y);
        if(k==1)
        {
            if(x>y)swap(x,y);
            printf("%lld\n", query(1,x,y).Ans);
        }
        else update(1,x,y);
    }
    return 0;
}

 

熙言丶
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线段树与区间最大子段和问题，这一篇就够了
m0_51156601的博客
04-08 3126
1、经典的区间最大子段和问题 问题描述：给定一个序列a1,a2,a3,..ana_1,a_2, a_3,..a_na1​,a2​,a3​,..an​，如何求出该序列的最大子段和？（询问的区间个数为mmm） 解决方案： - 暴力统计：对于每一个区间[l,r][l,r][l,r]，每一次选定一个子段的起点，然后枚举子段的长度，算法复杂度为O(mn2)O(mn^2)O(mn2)。 - 动态规划：我们一次性算出所有的区间的最大子段和，然后使用直接询问答案。我们规定： - ls\color{Green}lsls
线段树维护区间最大子段和
swunHJ的博客
08-07 674
感觉线段树白学了，遇到啥不会啥。 对于一个序列，要维护它的区间最大子段和，可以用线段树来做。当然，这是查询比较多的情况，比较少就直接O(n)DP了。 线段树维护4个东西： 1，区间答案，即该区间最大子段和 2，包含左端点的最大子段和 3，包含右端点的最大子段和 4，区间和 1是要维护的答案，2,3,4都是辅助来维护1的 具体操作： 区间答案可以由三种情况推出：qmax(qmax(...
区间最大子段和 + 最大子矩阵和 + 最大m子段和（DP）
道阻且长，行则将至
04-21 3251
动态规划解法： dp[i]表示以a[i]为结束的最大连续子段和 因为是以a[ i ]为结束且是连续子段 那么 dp[ i ] 要么就是 a[ i ]本身， 要么 就是a[ i ] + 以a[ i-1 ]为结束的最大连续字段和 也就是 a[ i ] + dp[ i - 1 ]， 所以 状态转移方程出来了 dp[i] = max（ a[i], dp[i-1]+a[i] ） （引用自最大连...
线段树维护(最大区间和，最大子段和，最长连续上升子序列）
不二君
05-02 1751
本文主要介绍用线段树来维护(最大区间和，最大子段和，最长连续上升子序列）的问题。 HDU 1540 Tunnel Warfare（最长连续区间+单点修改） 洛谷 P2894 [USACO08FEB]酒店Hotel（最长连续区间+区间修改） 吉首大学2019年程序设计竞赛-白山茶与红玫瑰（最长连续区间+区间修改） SPOJ - GSS1 Can you answer these querie...
[SGT] 线段树维护区间最大子段和
Zeolim的博客
08-09 334
蓝书P208 https://vjudge.net/problem/SPOJ-GSS1 若将一区间分为两部分，则必有最大子段存在于左区间 / 右区间 / 跨越中间 因此当前节点记录该段的最大前缀和，最大后缀和，段和，区间内最大子段和 now.sum = ls.sum + rs.sum; now.lmax = max(ls.lmax, ls.sum + rs.lmax); now.r...
线段树区间更新code
12-22
线段树区间更新代码线段树区间更新代码线段树区间更新代码线段树区间更新代码
权值线段树和主席树入门
09-25
权值线段树和主席树入门PPT，权值线段树，顾名思义就是记录权值的线段树，普通的线段树直接以坐标为l，r建树，而权值线段树是以大小来建树，树上寸的信息是该权值的数量，而通过建树时二分从小到大的性质，可以用这...
pascal区间线段树
11-18
否则，继续划分左子区间和右子区间，并更新当前节点的最小值为其两个子节点的最小值。 2. **revise(i, k, d: integer)**：用于修改数组元素的函数。输入参数 `i` 是当前节点的索引，`k` 是要修改的元素位置，`d` 是...
线段树（单点查询+区间求和）无lazy标记
01-20
原理就大概如图所示，线段树的每个节点都是原数组的一段区间和，而叶子节点就是原数组对应 的值 建树代码： void build(int p,int lf,int rt){//建树 ans[p]=0; if(lf==rt) { ans[p]=A[lf]; return ; } int mid...
C语言线段树讲解
最新发布
06-15
- 查询：快速求解区间内的某些性质，如区间和、区间最大值等。 - 更新：快速修改区间内的某个元素，如区间加减操作。 - 动态维护：在区间修改后，线段树可以快速更新结果。 6. **构建策略**： - 静态构建：一次...
【线段树】带修最大子段和模板
岂曰无衣，与子同袍
08-14 371
算是线段树里面很裸的一类题了，但是考场上忘记了怎么写qwq。 考试的题是环上的，补题的时候发现很熟悉，就想起来这一类模型之前刚学线段树老师讲过呀qwq（没有认真听讲），但是之前的板子已经被埋没在学校的老oj里面了，就还是重新写了一个模板： 小白逛公园 首先，线段树要维护这样四个域： sum：该区间的和 max：该区间上的最大子段和 maxl：为必须包含左端点的最大子段和（相当于最大前缀） maxr...
P4513 小白逛公园【线段树维护最大子段和】
独钓门前月
09-04 167
题意：就是维护带更新的最大子段和。 思路：sum是维护和，lm维护的是从左端点开始的答案，rm维护的是从右端点开始的答案，ans记录的就是答案。 那么在更新的时候，举个例子，更新lm时，要不就是左儿子的区间，或者跨过mid包含部分右区间的答案。 ans呢就是左右儿子的答案或者左右两个区间同时包含的答案。在查询的时候要注意，跟平常的查询略有不同。 #include <bits/std...
HDU 6638 Snowy Smile【线段树维护最大子段和】
独钓门前月
09-04 286
Snowy Smile Time Limit: 4000/4000 MS (Java/Others)Memory Limit: 524288/524288 K (Java/Others) Problem Description There arenpirate chests buried in Byteland, labeled by1,2,…,n. Thei-th ch...
线段树维护区间子段和（模板题）
这里RevolIA，_(:з」∠)_
08-09 478
题目链接、 题意： 给定长度为N的数列A，以及M条指令，每条指令可能是以下两种之一： 1、“1 x y”，查询区间 [x,y] 中的最大连续子段和，即 2、“2 x y”，把 A[x] 改成 y 对于每个查询指令，输出一个整数表示答案。 题解： 线段树维护 一、线段树的精髓——区间合并，考虑怎么合并就行了： 1、合并的答案要么左区间的子段和，要么是右区间的子段和，要么是中间的一...
[多重解法]线段树练习(动态求连续区间和,区间最大值)
☆迷茫Dog的秘密基地☆
03-11 1729
目标:求任意动态区间元素的最值or总和 场景描述: 给定了一个数组,接下来求指定区间的最值或总和,最简单的做法便是直接遍历该区间,但数组可能非常大或者会对其中的数再做修改,每次都暴力会超时 线段树满足完全二叉树的性质,能将时间复杂度降到O()级别
线段树详解（单点修改+区间修改和查询）
热门推荐
菜鸡成长史
07-03 1万+
【...】 把之前做的线段树的理论总结做了一个整合和一点修改。 线段树不能只是会用板子而已，要理解并且熟练，不假思索分分钟就能敲出来才行。 单点修改+区间修改和查询 例题+代码 目录 【线段树】 【引入】 【概述】 【单点修改和查询】 【建树】 【单点修改】 【区间查询最小值】 【区间查询区间和】 【区间修改和查询】 【延迟标记】 【标记下传】 【标记永久化】 ...
【挖坑】【GSS系列】GSS3:带单点修改的区间最大子段和
Fighter的博客
03-15 456
Can you answer these queries? ​ GSS系列是spoj出品的一套数据结构好毒瘤题，主要以线段树、平衡树和树链剖分为背景，进行了一些操作的魔改，使得难度远超模板题，但对于思维有极大的提升。 ​ 所以我会选择一些在我能力范围内的题挖坑选讲，构成一个GSS系列。至于剩下那些，等我成为巨佬弄懂了再说吧。 GSS3:带单点修改的区间最大子段和 ​ 本文有前置芝士：GSS1。...
线段树维护区间最大连续和
Gloria971111的博客
01-26 1735
在我的理解中，线段树就是线段组成的树，越靠近根部的层，线段的长度越长，一个结构体（树的每一个点的左边界，右边界以及要维护的值）和三个函数（build——拆的过程），update（更新的过程，更新的时候要先二分找到最底层的区间，然后需要向上将所有的区间都更新了），query（寻找的过程）。 http://acm.uestc.edu.cn/#/problem/show/844 这个题目的意思就是给
I Hate It（线段树维护区间最大值）
Joker_He的博客
02-21 427
题目传送门 题意：给定一个原始数组，有2种操作，第一种操作是单点修改ID为A的学生的成绩改为B，第二种操作是询问区间A到B中分值最大的一位。 思路 用线段树维护区间最大值，每次修改之后不断向上更新区间最大值即可。 代码 #include<bits/stdc++.h> using namespace std; typedef long long ll; const int N=2e5+5...
python线段树实现查找区间内最大的值
06-12
下面是使用 Python 实现线段树查找区间内最大值的代码： ```python class SegmentTree: def __init__(self, nums): self.n = len(nums) self.tree = [0] * (self.n * 4) self.build_tree(nums, 0, 0, self.n - ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值