Toocold之区间最大子段和

最新推荐文章于 2022-03-19 18:14:19 发布
最新推荐文章于 2022-03-19 18:14:19 发布
阅读量1.2k 收藏 3
点赞数 1
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44061561/article/details/94391772
版权

Toocold学会了怎样求区间最大子段和,现在他又玩出了新花样.他有n个数,他想知道对于区间的左端点l限定在[ll,rr]之间, 对于区间的右端点r限定在[ll2,rr2]之间的区间最大和是多少?

Input

输入第一行cas(1<=cas<=10)表示有几个cas

接下来每个cas的第一行是一个数n(1<=n<=100000)表示有n个数

第二行有n个数,a1,a2,a3...an(-1000<=ai<=1000)

第三行一个数q(1<=q<=100000)表示有q个询问

接下来q行每行四个数字ll, rr, ll2, rr2.(1<=ll,rr,ll2,rr2<=n)(ll<=rr)(ll2<=rr2)(rr2>=ll)
表示左端点l的范围和右端点r的范围

Output

每个询问输出符合范围的区间最大和

Sample Input

1
6
4 -3 1 -3 5 -2
2
1 4 2 5
1 1 3 4

Sample Output

4
2

Hint

div2(D)

#include<bits/stdc++.h>
using namespace std;
const int MAXN=100015;
int n,m;
int a[MAXN],pre_sum[MAXN],suf_sum[MAXN],l1,l2,r1,r2;
struct tnode
{
    int sum,lmax,rmax,ans;
	int l,r;
};
tnode operator + (const tnode& a,const tnode& b)
{
    tnode c;
    c.l=a.l;
    c.r=b.r;
    c.sum=a.sum+b.sum;
    c.lmax=max(a.lmax,a.sum+b.lmax);
    c.rmax=max(a.rmax+b.sum,b.rmax);
    c.ans=max(a.ans,b.ans);
    c.ans=max(c.ans,a.rmax+b.lmax);
    return c;
}
struct Segment_Tree
{
	tnode t[4*MAXN];
	void update(int root)
	{
	    int ch=root<<1;
	    t[root]=t[ch]+t[ch+1];
	}
	void buildt(int root,int l,int r,int A[])
	{
		if(l!=r)
		{
			int mid=(l+r)>>1;
			int ch=root<<1;
			buildt(ch,l,mid,A);
			buildt(ch+1,mid+1,r,A);
			update(root);
		}
		else
        {
            t[root].ans=t[root].lmax=t[root].rmax=t[root].sum=A[l];
            t[root].l=t[root].r=l;
        }
	}
	tnode query(int root,int l,int r)
	{
		if(t[root].l==l&&t[root].r==r)
		{
			return t[root];
		}
		int mid=(t[root].l+t[root].r)>>1;
		int ch=root<<1;
		if(r<=mid)return query(ch,l,r);
		else if(l>mid)return query(ch+1,l,r);
		else return query(ch,l,mid)+query(ch+1,mid+1,r);
	}
};
Segment_Tree ST1;
struct tnodes
{
    int Max;
	int l,r;
};
struct Segment_Tree_Max
{
	tnodes t[4*MAXN];
	void buildt(int root,int l,int r,int A[])
	{
		t[root].l=l;
		t[root].r=r;
		if(l!=r)
		{
			int mid=(l+r)>>1;
			int ch=root<<1;
			buildt(ch,l,mid,A);
			buildt(ch+1,mid+1,r,A);
			t[root].Max=max(t[ch].Max,t[ch+1].Max);
		}
		else t[root].Max=A[l];
	}
	int query(int root,int l,int r)
	{
		if(t[root].l==l&&t[root].r==r)
		{
			return t[root].Max;
		}
		int mid=(t[root].l+t[root].r)>>1;
		int ch=root<<1;
		if(r<=mid)return query(ch,l,r);
		else if(l>mid)return query(ch+1,l,r);
		else return max(query(ch,l,mid),query(ch+1,mid+1,r));
	}
};
Segment_Tree_Max ST2,ST3;
int get_sum(int l,int r)
{
    if(l>r)return 0;
    return pre_sum[r]-pre_sum[l-1];
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d",&n);
        for(int i=1;i<=n;++i)
        {
            scanf("%d",&a[i]);
        }
        ST1.buildt(1,1,n,a);
        pre_sum[0]=suf_sum[n+1]=0;
        for(int i=1;i<=n;++i)
        {
            pre_sum[i]=pre_sum[i-1]+a[i];
        }
        for(int i=n;i;--i)
        {
            suf_sum[i]=suf_sum[i+1]+a[i];
        }
        ST2.buildt(1,1,n,pre_sum);
        ST3.buildt(1,1,n,suf_sum);
        scanf("%d",&m);
        while(m--)
        {
            scanf("%d %d %d %d",&l1,&r1,&l2,&r2);
            if(r1<l2)///3 无交
            {
                printf("%d\n",ST3.query(1,l1,r1)-pre_sum[n]+ST2.query(1,l2,r2));
            }
            else if(l2<=l1&&l1<=r2&&r2<=r1)///2
            {
                printf("%d\n",ST1.query(1,l1,r2).ans);
            }
            else if(l1<=l2&&l2<=r1&&r1<=r2)///1
            {
                int temp=ST1.query(1,l2,r1).ans;
                if(l2-1>=l1)
                {
                    temp=max(temp,ST3.query(1,l1,l2-1)-pre_sum[n]+ST2.query(1,l2,r2));
                }
                if(r1+1<=r2)
                {
                    temp=max(temp,ST2.query(1,r1+1,r2)-pre_sum[n]+ST3.query(1,l1,r1));
                }
                printf("%d\n",temp);
            }
            else if(l1<=l2&&l2<=r2&&r2<=r1)///4
            {
                int temp=ST1.query(1,l2,r2).ans;
                if(l2-1>=l1)
                {
                    temp=max(temp,ST3.query(1,l1,l2-1)-pre_sum[n]+ST2.query(1,l2,r2));
                }
                printf("%d\n",temp);
            }
            else if(l2<=l1&&l1<=r1&&r1<=r2)///5
            {
                int temp=ST1.query(1,l1,r1).ans;
                if(r1+1<=r2)
                {
                    temp=max(temp,ST2.query(1,r1+1,r2)-pre_sum[n]+ST3.query(1,l1,r1));
                }
                printf("%d\n",temp);
            }
        }
    }
    return 0;
}

#include<bits/stdc++.h>
using namespace std;
const long long MAXN=100015;
long long n,m;
long long a[MAXN],pre_sum[MAXN],suf_sum[MAXN],l1,l2,r1,r2;
struct tnode
{
    long long sum,lmax,rmax,ans;
	long long l,r;
};
tnode operator + (const tnode& a,const tnode& b)
{
    tnode c;
    c.l=a.l;
    c.r=b.r;
    c.sum=a.sum+b.sum;
    c.lmax=max(a.lmax,a.sum+b.lmax);
    c.rmax=max(a.rmax+b.sum,b.rmax);
    c.ans=max(a.ans,b.ans);
    c.ans=max(c.ans,a.rmax+b.lmax);
    return c;
}
struct Segment_Tree
{
	tnode t[4*MAXN];
	void update(long long root)
	{
	    long long ch=root<<1;
	    t[root]=t[ch]+t[ch+1];
	}
	void buildt(long long root,long long l,long long r,long long A[])
	{
		if(l!=r)
		{
			long long mid=(l+r)>>1;
			long long ch=root<<1;
			buildt(ch,l,mid,A);
			buildt(ch+1,mid+1,r,A);
			update(root);
		}
		else
        {
            t[root].ans=t[root].lmax=t[root].rmax=t[root].sum=A[l];
            t[root].l=t[root].r=l;
        }
	}
	tnode query(long long root,long long l,long long r)
	{
		if(t[root].l==l&&t[root].r==r)
		{
			return t[root];
		}
		long long mid=(t[root].l+t[root].r)>>1;
		long long ch=root<<1;
		if(r<=mid)return query(ch,l,r);
		else if(l>mid)return query(ch+1,l,r);
		else return query(ch,l,mid)+query(ch+1,mid+1,r);
	}
};
Segment_Tree ST1;
struct tnodes
{
    long long Max;
	long long l,r;
};
struct Segment_Tree_Max
{
	tnodes t[4*MAXN];
	void buildt(long long root,long long l,long long r,long long A[])
	{
		t[root].l=l;
		t[root].r=r;
		if(l!=r)
		{
			long long mid=(l+r)>>1;
			long long ch=root<<1;
			buildt(ch,l,mid,A);
			buildt(ch+1,mid+1,r,A);
			t[root].Max=max(t[ch].Max,t[ch+1].Max);
		}
		else t[root].Max=A[l];
	}
	long long query(long long root,long long l,long long r)
	{
		if(t[root].l==l&&t[root].r==r)
		{
			return t[root].Max;
		}
		long long mid=(t[root].l+t[root].r)>>1;
		long long ch=root<<1;
		if(r<=mid)return query(ch,l,r);
		else if(l>mid)return query(ch+1,l,r);
		else return max(query(ch,l,mid),query(ch+1,mid+1,r));
	}
};
Segment_Tree_Max ST2,ST3;
long long get_sum(long long l,long long r)
{
    if(l>r)return 0;
    return pre_sum[r]-pre_sum[l-1];
}
int main()
{
    long long T;
    scanf("%lld",&T);
    while(T--)
    {
        scanf("%lld",&n);
        assert(n<=100000);
        for(long long i=1;i<=n;++i)
        {
            scanf("%lld",&a[i]);
            assert(-1000<=a[i]&&a[i]<=1000);
        }
        ST1.buildt(1,1,n,a);
        pre_sum[0]=suf_sum[n+1]=0;
        for(long long i=1;i<=n;++i)
        {
            pre_sum[i]=pre_sum[i-1]+a[i];
        }
        for(long long i=n;i;--i)
        {
            suf_sum[i]=suf_sum[i+1]+a[i];
        }
        ST2.buildt(1,1,n,pre_sum);
        ST3.buildt(1,1,n,suf_sum);
        scanf("%lld",&m);
        while(m--)
        {
            long long ans;
            scanf("%lld %lld %lld %lld",&l1,&r1,&l2,&r2);
            assert(l1<=r1);
            assert(l2<=r2);
            assert(r2>=l1);
            if(r1<l2)///3 无交
            {
                ans=ST3.query(1,l1,r1)-pre_sum[n]+ST2.query(1,l2,r2);
            }
            else if(l2<=l1&&l1<=r2&&r2<=r1)///2
            {
                ans=ST1.query(1,l1,r2).ans;
            }
            else if(l1<=l2&&l2<=r1&&r1<=r2)///1
            {
                long long temp=ST1.query(1,l2,r1).ans;
                if(l2-1>=l1)
                {
                    temp=max(temp,ST3.query(1,l1,l2-1)-pre_sum[n]+ST2.query(1,l2,r2));
                }
                if(r1+1<=r2)
                {
                    temp=max(temp,ST2.query(1,r1+1,r2)-pre_sum[n]+ST3.query(1,l1,r1));
                }
                ans=temp;
            }
            else if(l1<=l2&&l2<=r2&&r2<=r1)///4
            {
                long long temp=ST1.query(1,l2,r2).ans;
                if(l2-1>=l1)
                {
                    temp=max(temp,ST3.query(1,l1,l2-1)-pre_sum[n]+ST2.query(1,l2,r2));
                }
                ans=temp;
            }
            else if(l2<=l1&&l1<=r1&&r1<=r2)///5
            {
                long long temp=ST1.query(1,l1,r1).ans;
                if(r1+1<=r2)
                {
                    temp=max(temp,ST2.query(1,r1+1,r2)-pre_sum[n]+ST3.query(1,l1,r1));
                }
                ans=temp;
            }
            printf("%lld\n",ans);
        }
    }
    return 0;
}
izhengtl2021
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
区间最大子段和(线段树)
cy41的博客
04-23 2098
题目链接：https://www.acwing.com/problem/content/246/ 意思就是给你n个数，q次操作，每次改一个值，或者询问区间[L,R]内最大的连续子段和。 线段树维护四个东西，区间和，区间最大子段和，紧靠区间左端点的最大子段和，紧靠区间右端点的最大子段和。 sum[],lmax[].rmax[],dat[]，分别表示上述四种东西。 sum不用说吧。 对于lm...
最大子区域问题
Owen_Q的博客
10-08 605
最大子区域问题也是笔试面试非常常见的问题，典型的就是数组的最大子串和矩阵的最大子矩阵，一般伴随着求和求积这类操作。 下面我们就来研究一下。 53.Maximum Subarray 题意： 最大子区域问题的最经典类型就是数组的最大子区间和问题 思路： dp枚举每个位置，动态维护以当前元素为结尾的最大子区间和总最大子区间，转移只需要与前项比较即可 代码： /* Author Owen_Q */ class Solution { public: int maxSubArray(vec.
最大子段和问题
weixin_33674976的博客
02-01 1015
经典的动态规划问题，几乎所有的算法教材都会提到.本文将分析最大子段和问题的几种不同效率的解法，以及最大子段和问题的扩展和运用. 一.问题描述 给定长度为n的整数序列，a[1...n], 求[1,n]某个子区间[i , j]使得a[i]+…+a[j]和最大.或者求出最大的这个和.例如(-2,11,-4,13,-5,2)的最大子段和为20,所求子区间为[2,4]. 二. 问题分析 1.穷举法 ...
最大子段和
林苏泽
04-19 566
问题 A: 最大子段和 时间限制: 1 Sec 内存限制: 128 MB [提交] [状态] 题目描述 Geobiyye是一个喜欢思考问题的女孩子。 Geobiyye给了你一个序列，她想求出这个序列的最大子段和。 Geobiyye觉得这个问题太简单了，她将问题扩大了一倍。于是现在问题变成了：从这个序列中选出不相交的两个连续段，要求它们的和最大。 换句话说，对于给定的长度为n的序列ai，你需要给出...
求区间最大连续子段和.new（线段树）
Coco_T的博客
10-03 2343
这个故事是这样的： 在n年前，憨憨博主在参加省队集训的时候，第一次接触到了这个问题：区间最大连续子段和， 于是博主就开始一阵恶补，get了这种新技能 然而在夏季的一个宁静的午后，博主的CSDN突然接到消息通知，发现好心的大佬给我指出了我写的代码的不足，憨憨博主非常惭愧。。。 前端时间都在忙着大学的各种事项，没有抽出时间来修正这个错误 十一假期留校，突然想起来了我好像还有个大坑没有填，于是就上网查看......
区间最大子段和 + 最大子矩阵和 + 最大m子段和（DP）
道阻且长，行则将至
04-21 3256
动态规划解法： 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] ） （引用自最大连...
51nod 1254 最大子段和 V2
OZY的博客
03-06 795
题意 N个整数组成的序列a[1],a[2],a[3],…,a[n]，你可以对数组中的一对元素进行交换，并且交换后求a[1]至a[n]的最大子段和，所能得到的结果是所有交换中最大的。当所给的整数均为负数时和为0。 例如：{-2,11,-4,13,-5,-2, 4}将 -4 和 4 交换，{-2,11,4,13,-5,-2, -4}，最大子段和为11 + 4 + 13 = 28。 题解 首...
区间和 | 区间最值-区间k大
From2016cxg
07-20 570
区间和1.递推-维护动态规划表 | 一维复杂度O(n) , 二维O(mn) 一维区间连续和：d[i]含义-区间[1,i]前缀和，递推公式 d[i] = d[i-1] + A[i] , 递推条件d[0] = 0 二维矩形区域和：d[i][j]含义-矩形( [1,i] , [1,j] ) 前缀矩形区域和 递推公式d[i][j] = d[i][j-1] + d[i-1][j] + A
HDU 6444 Neko's loop(线段树+裴蜀定理/最长子段和)
咸鱼有梦想
09-09 270
题目链接 Neko's loop Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others) Total Submission(s): 1557    Accepted Submission(s): 362   Problem Description Neko has a loop ...
【动态规划】最大子段和
咸鱼的博客
03-07 2020
动态规划之最大子段和问题 问题描述： 给定长度为n的整数序列，a[1...n], 求[1,n]某个子区间[i , j]使得a[i]+…+a[j]和最大.或者求出最大的这个和.例如(-2,11,-4,13,-5,2)的最大子段和为20,所求子区间为[2,4]. 1.穷举法 枚举左右区间然后遍历该区间求解，时间复杂度O(n3) 2.穷举法+前缀和 在第一种方法的基础上，预处理出前缀和，在枚...
【1052】 最大M子段和 （dp）
Coldfresh的博客
09-05 405
N个整数组成的序列a[1],a[2],a[3],…,a[n]，将这N个数划分为互不相交的M个子段，并且这M个子段的和是最大的。如果M &gt;= N个数中正数的个数，那么输出所有正数的和。 例如：-2 11 -4 13 -5 6 -2，分为2段，11 -4 13一段，6一段，和为26。 Input 第1行：2个数N和M，中间用空格分隔。N为整数的个数，M为划分为多少段。（2 &lt;= N ...
UVALive 6748 2D-Solar System
Tooc0ld
08-14 220
按照初始位置排序，那么答案必定小于等于相邻两个圆相切的情况。 注意到对于一个圆，令左端离他最近的半径比他大的圆的位置为L，右端离他最近的半径比他大的圆的位置为R，这个圆只会受到L到R这段区间的影响。 所以维护一个半径单调递减的栈即可。
51nod 1052 最大M子段和(dp)
blog
08-24 138
n个数,切为m段,最大和 n,m&lt;=5e3 dp[i][j],使用前i个数(!!!第i个数被使用!!!),分为j段的最大和. 每到一个点,他最大的这个dp状态,要不是和前面一个连着最大,要不就是不和前面一个连着的最大. #include &lt;iostream&gt; #include &lt;vector&gt; #include &lt;algorithm&gt; #incl...
四种方法求解最大子段和问题
weixin_44755413的博客
04-13 9306
题目描述 给定一段长度为n的序列，我们需要找到其中一个连续的子段，使这个子段中各个元素加和最大，如果这个数组中全为负整数，我们就定义这个子段和为0. 题目分析 首先我们的目的是找一个局部的子段但加和是全局最大，所以我们可以很自然地想到，直接暴力法遍历求解即可。 方法一.暴力法求解 我们设置一个i，从第1个位置开始遍历，这个i表示的是我们最大子段的起始位置，然后我们从j=i往后接着遍历，j表示的是...
http://39.98.219.132 题库标准答案(题库序号:1375)之最大子区间（3）
yys365的博客
03-19 254
序号:1375 最大子区间（3） Time Limit:1sMemory Limit:512MB 题目描述： 假设有n(1<=n<=1000000)个整数组成一个数列a：a1, a2, a3, a4...an。求数列a中连续若干个数的和的最大值。 输入格式: 第一行整数n 第二行n个整数，用单个空格隔开 输出格式： 一个整数 输入样例： 4 4 -1 7 -2 输出样例： 10 样例解释 连续1个数的和：4； -1； 7； -2 连续2个数的和：4-1=3； -.
最大子区间和
新博客：https://aping-dev.com/
10-11 1638
#include "stdio.h" #include "stdlib.h" #include "math.h" #include "string.h" #define N 100int MaxSum(int a[N], int n) //计算区间a[0:n-1]上最大子区间长度 { int i; int b = 0; int sum = 0; for(i=0; i
SPOJ GSS1 (区间最大子段和)（线段树）
ShadowGhostH的博客
08-12 1083
想要补camp里的那道区间最大k子段和，结果发现自己连怎么求区间最大字段和都不会。。。菜是原罪，于是找了GSS来补一下（虽然我连GSS是什么都不知道hhh 题目 题意 给一个长度为nnn的序列，mmm次查询，每次查询一个区间[l,r][l,r][l,r]中的最大子段和（要求为连续子序列）。 思路 对于一个固定区间，求最大子段和我们有O(n)O(n)O\left(n\right)的...
动态区间最大子段和
weixin_43678350的博客
02-27 1036
题目描述 Description 题目还是简单一点好… 有n个数，a[1]到a[n]。 接下来q次查询，每次动态指定两个数l,r，求a[l]到a[r]的最大子段和。 子段的意思是连续非空区间。 输入描述 Input Description 第一行一个数n。 第二行n个数a[1]~a[n]。 第三行一个数q。 以下q行每行两个数l和r。 输出描述 Output Description q行，每行一个...
spoj GSS1.区间最大子段和(线段树)
nan
08-07 1479
区间最大子段和 You are given a sequence A[1],A[2],...,A[N].(|A[i]|≤15007,1≤N≤50000)A[1],A[2],...,A[N].(|A[i]|≤15007,1≤N≤50000)A[1], A[2], ..., A[N]. ( |A[i]| ≤ 15007 , 1 ≤ N ≤ 50000). A query is defined as ...
FZU 2253 Salty Fish 【区间最大子段和】【简单DP】
Emiya丶的博客
06-07 665
Problem 2253 Salty Fish Accept: 414    Submit: 1501Time Limit: 1000 mSec    Memory Limit : 32768 KB Problem Description海边躺着一排咸鱼，一些有梦想的咸鱼成功翻身（然而没有什么卵用），一些则是继续当咸鱼。一个善良的渔夫想要帮这些咸鱼翻身，但是渔夫比较懒，所以只会从某只咸鱼开始，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值