吉如一线段树:区间最值和历史最值

最新推荐文章于 2024-11-09 21:51:15 发布
最新推荐文章于 2024-11-09 21:51:15 发布
阅读量940 收藏 26
点赞数 31
分类专栏： 专题训练总结 文章标签： 算法 c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_78527293/article/details/142740350
版权

区间最值和历史最值

问题一

给定一个长度为 n n n 的数组 a a a , 实现以下三种操作 :

0 l r x : 将 a r r [ l ∼ r ] arr[l\sim r] arr[l∼r] 范围的每个数 v v v , 更新为 min ⁡ ( v , x ) \min (v, x) min(v,x)

1 l r : 查询 max ⁡ i = l r a r r i \max_{i=l}^r arr_i maxi=lr​arri​

2 l r : 查询 ∑ i = l r a r r i \sum_{i=l}^rarr_i ∑i=lr​arri​

吉如一线段树。

#include<bits/stdc++.h>
using namespace std;
#define int long long

#define lc u << 1
#define rc u << 1 | 1

int const N = 5e5 + 10;

struct node{
    // mx : 最大值 ; cnt : mx 出现次数
    // se : 第二大
    // sum : 区间和
    int l, r, mx, cnt, se, sum;
}tr[N << 2];

int a[N];

void pushup(int u){
    tr[u].sum = tr[lc].sum + tr[rc].sum;
    tr[u].mx = max(tr[lc].mx, tr[rc].mx);
    if(tr[lc].mx == tr[rc].mx){
        tr[u].cnt = tr[lc].cnt + tr[rc].cnt;
        tr[u].se = max(tr[lc].se, tr[rc].se);
    }
    else if(tr[lc].mx > tr[rc].mx){
        tr[u].cnt = tr[lc].cnt;
        tr[u].se = max(tr[lc].se, tr[rc].mx);
    }
    else{
        tr[u].cnt = tr[rc].cnt;
        tr[u].se = max(tr[lc].mx, tr[rc].se);
    }
}

void pushdown(int u){
    if(tr[lc].mx > tr[u].mx){ // 标记回收
        tr[lc].sum -= (tr[lc].mx - tr[u].mx) * tr[lc].cnt;
        tr[lc].mx = tr[u].mx;
    }
    if(tr[rc].mx > tr[u].mx){ // 标记回收
        tr[rc].sum -= (tr[rc].mx - tr[u].mx) * tr[rc].cnt;
        tr[rc].mx = tr[u].mx;
    }
}

void build(int u, int l, int r){
    tr[u] = {l, r, a[l], 1, LLONG_MIN, a[l]};
    if(l == r) return ;
    int mid = l + r >> 1;
    build(lc, l, mid);
    build(rc, mid + 1, r);
    pushup(u);
}

void setMin(int u, int l, int r, int x){
    if(x >= tr[u].mx) return ;
    if(l <= tr[u].l && r >= tr[u].r && x > tr[u].se){
        tr[u].sum -= (tr[u].mx - x) * tr[u].cnt;
        tr[u].mx = x;
        return ;
    }
    pushdown(u);
    int mid = tr[u].l + tr[u].r >> 1;
    if(l <= mid) setMin(lc, l, r, x);
    if(r > mid) setMin(rc, l, r, x);
    pushup(u);
}

int askMax(int u, int l, int r){
    if(l <= tr[u].l && r >= tr[u].r){
        return tr[u].mx;
    }
    int mid = tr[u].l + tr[u].r >> 1;
    pushdown(u);
    int res = LLONG_MIN;
    if(l <= mid) res = max(res, askMax(lc, l, r));
    if(r > mid) res = max(res, askMax(rc, l, r));
    return res;
}

int askSum(int u, int l, int r){
    if(l <= tr[u].l && r >= tr[u].r){
        return tr[u].sum;
    }
    int mid = tr[u].l + tr[u].r >> 1;
    pushdown(u);
    int sum = 0;
    if(l <= mid) sum += askSum(lc, l, r);
    if(r > mid) sum += askSum(rc, l, r);
    return sum;
}

void solve(){
    int n, q;
    cin >> n >> q;
    for(int i = 1; i <= n; i ++){
        cin >> a[i];
    }
    build(1, 1, n);

    while(q --){
        int op, l, r, t;
        cin >> op >> l >> r;
        if(op == 0){
            cin >> t;
            setMin(1, l, r, t);
        }
        else if(op == 1){
            cout << askMax(1, l, r) << '\n';
        }
        else{
            cout << askSum(1, l, r) << '\n';
        }
    }
}

signed main(){
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0); 

    int T;
    cin >> T;
    while(T --){
        solve();
    }
    return 0;
}

问题二

题目背景

本题是线段树维护区间最值操作与区间历史最值的模板。

题目描述

给出一个长度为 n n n 的数列 A A A，同时定义一个辅助数组 B B B， B B B 开始与 A A A 完全相同。接下来进行了 m m m 次操作，操作有五种类型，按以下格式给出：

  • 1 l r k：对于所有的 i ∈ [ l , r ] i\in[l,r] i∈[l,r]，将 A i A_i Ai​ 加上 k k k（ k k k 可以为负数）。
  • 2 l r v：对于所有的 i ∈ [ l , r ] i\in[l,r] i∈[l,r]，将 A i A_i Ai​ 变成 min ⁡ ( A i , v ) \min(A_i,v) min(Ai​,v)。
  • 3 l r：求 ∑ i = l r A i \sum_{i=l}^{r}A_i ∑i=lr​Ai​。
  • 4 l r：对于所有的 i ∈ [ l , r ] i\in[l,r] i∈[l,r]，求 A i A_i Ai​ 的最大值。
  • 5 l r：对于所有的 i ∈ [ l , r ] i\in[l,r] i∈[l,r]，求 B i B_i Bi​ 的最大值。

在每一次操作后，我们都进行一次更新，让 B i ← max ⁡ ( B i , A i ) B_i\gets\max(B_i,A_i) Bi​←max(Bi​,Ai​)。

输入格式

第一行包含两个正整数 n , m n,m n,m，分别表示数列 A A A 的长度和操作次数。

第二行包含 n n n 个整数 A 1 , A 2 , ⋯   , A n A_1,A_2,\cdots,A_n A1​,A2​,⋯,An​，表示数列 A A A。

接下来 m m m 行，每行行首有一个整数 o p op op，表示操作类型；接下来两个或三个整数表示操作参数，格式见【题目描述】。

输出格式

对于 o p ∈ { 3 , 4 , 5 } op\in\{3,4,5\} op∈{3,4,5} 的操作，输出一行包含一个整数，表示这个询问的答案。

样例 #1

样例输入 #1

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

样例输出 #1

14
6
6
11

提示

样例说明 #1
操作次数输入内容操作数列输出结果
0 1 , 2 , 3 , 4 , 5 1,2,3,4,5 1,2,3,4,5
13 2 5求出 [ 2 , 5 ] [2,5] [2,5] 所有数的和 1 , 2 , 3 , 4 , 5 1,2,3,4,5 1,2,3,4,514
21 1 3 3将 [ 1 , 3 ] [1,3] [1,3] 内所有数加 3 3 3 4 , 5 , 6 , 4 , 5 4,5,6,4,5 4,5,6,4,5
34 2 4求出 [ 2 , 4 ] [2,4] [2,4] 所有数的最大值 4 , 5 , 6 , 4 , 5 4,5,6,4,5 4,5,6,4,56
42 3 4 1将 [ 3 , 4 ] [3,4] [3,4] 所有数与 1 1 1 取最小值 4 , 5 , 1 , 1 , 5 4,5,1,1,5 4,5,1,1,5
55 1 5求出 [ 1 , 5 ] [1,5] [1,5] 所有位置历史最大值的最大值 4 , 5 , 1 , 1 , 5 4,5,1,1,5 4,5,1,1,56
63 1 4求出 [ 1 , 4 ] [1,4] [1,4] 所有数的和 4 , 5 , 1 , 1 , 5 4,5,1,1,5 4,5,1,1,511
数据规模与约定
  • 对于测试点 1 , 2 1,2 1,2，满足 n , m ≤ 5000 n,m\leq 5000 n,m≤5000；
  • 对于测试点 3 , 4 3,4 3,4，满足 o p ∈ { 1 , 2 , 3 , 4 } op\in\{1,2,3,4\} op∈{1,2,3,4}；
  • 对于测试点 5 , 6 5,6 5,6，满足 o p ∈ { 1 , 3 , 4 , 5 } op\in\{1,3,4,5\} op∈{1,3,4,5}；
  • 对于全部测试数据，保证 1 ≤ n , m ≤ 5 × 1 0 5 1\leq n,m\leq 5\times 10^5 1≤n,m≤5×105， − 5 × 1 0 8 ≤ A i ≤ 5 × 1 0 8 -5\times10^8\leq A_i\leq 5\times10^8 −5×108≤Ai​≤5×108， o p ∈ [ 1 , 5 ] op\in[1,5] op∈[1,5]， 1 ≤ l ≤ r ≤ n 1 \leq l\leq r \leq n 1≤l≤r≤n， − 2000 ≤ k ≤ 2000 -2000\leq k\leq 2000 −2000≤k≤2000， − 5 × 1 0 8 ≤ v ≤ 5 × 1 0 8 -5\times10^8\leq v\leq 5\times10^8 −5×108≤v≤5×108。
提示

本题输入量较大，请使用合理高效的读入方法。

#include<bits/stdc++.h>
using namespace std;
#define int long long

#define lc u << 1
#define rc u << 1 | 1

int const N = 5e5 + 10;

struct node{
	// mx : 最大值 ; cnt : mx 出现次数
	// se : 第二大
	// sum : 区间和
	// mxhis : 历史最大值
	// add1, add2 : 区间最大值/非最大的懒标记
	// add3, add4 : 最大值懒标记历史最大值, 非最大值懒标记最历史大值
	int l, r, mx, cnt, se, sum, mxhis;
	int add1, add2, add3, add4;
}tr[N << 2];

int a[N];

void pushup(int u){
	tr[u].sum = tr[lc].sum + tr[rc].sum;
	tr[u].mx = max(tr[lc].mx, tr[rc].mx);
	tr[u].mxhis = max(tr[lc].mxhis, tr[rc].mxhis);
	if(tr[lc].mx == tr[rc].mx){
		tr[u].cnt = tr[lc].cnt + tr[rc].cnt;
		tr[u].se = max(tr[lc].se, tr[rc].se);
	}
	else if(tr[lc].mx > tr[rc].mx){
		tr[u].cnt = tr[lc].cnt;
		tr[u].se = max(tr[lc].se, tr[rc].mx);
	}
	else{
		tr[u].cnt = tr[rc].cnt;
		tr[u].se = max(tr[lc].mx, tr[rc].se);
	}
}

void down(int u, int add1, int add2, int add3, int add4){
	tr[u].sum += add1 * tr[u].cnt + add2 * (tr[u].r - tr[u].l + 1 - tr[u].cnt);
	tr[u].mxhis = max(tr[u].mxhis, tr[u].mx + add3);
	tr[u].mx += add1;
	if(tr[u].se != LLONG_MIN) tr[u].se += add2;
	tr[u].add3 = max(tr[u].add3, tr[u].add1 + add3);
	tr[u].add4 = max(tr[u].add4, tr[u].add2 + add4);
	tr[u].add1 += add1;
	tr[u].add2 += add2;
}

void pushdown(int u){
	int maxn = max(tr[lc].mx, tr[rc].mx);
	if(tr[lc].mx == maxn){
		down(lc, tr[u].add1, tr[u].add2, tr[u].add3, tr[u].add4);
	}
	else{
		down(lc, tr[u].add2, tr[u].add2, tr[u].add4, tr[u].add4);
	}
	if(tr[rc].mx == maxn){
		down(rc, tr[u].add1, tr[u].add2, tr[u].add3, tr[u].add4);
	}
	else{
		down(rc, tr[u].add2, tr[u].add2, tr[u].add4, tr[u].add4);
	}
	tr[u].add1 = tr[u].add2 = tr[u].add3 = tr[u].add4 = 0;
}

void build(int u, int l, int r){
	tr[u] = {l, r, a[l], 1, LLONG_MIN, a[l], a[l], 0, 0, 0, 0};
	if(l == r) return ;
	int mid = l + r >> 1;
	build(lc, l, mid);
	build(rc, mid + 1, r);
	pushup(u);
}

void segAdd(int u, int l, int r, int x){
	if(l <= tr[u].l && r >= tr[u].r){
		tr[u].sum += x * (tr[u].r - tr[u].l + 1);
		tr[u].mx += x;
		tr[u].mxhis = max(tr[u].mx, tr[u].mxhis);
		if(tr[u].se != LLONG_MIN) tr[u].se += x;
		tr[u].add1 += x, tr[u].add2 += x;
		tr[u].add3 = max(tr[u].add3, tr[u].add1);
		tr[u].add4 = max(tr[u].add4, tr[u].add2);
		return ;
	}
	int mid = tr[u].l + tr[u].r >> 1;
	pushdown(u);
	if(l <= mid) segAdd(lc, l, r, x);
	if(r > mid) segAdd(rc, l, r, x);
	pushup(u);
}

void setMin(int u, int l, int r, int x){
	if(x >= tr[u].mx) return ;
	if(l <= tr[u].l && r >= tr[u].r && x > tr[u].se){
		int t = tr[u].mx - x;
		tr[u].sum -= t * tr[u].cnt;
		tr[u].mx = x;
		tr[u].add1 -= t;
		return ;
	}
	pushdown(u);
	int mid = tr[u].l + tr[u].r >> 1;
	if(l <= mid) setMin(lc, l, r, x);
	if(r > mid) setMin(rc, l, r, x);
	pushup(u);
}

int askMax(int u, int l, int r){
	if(l <= tr[u].l && r >= tr[u].r){
		return tr[u].mx;
	}
	int mid = tr[u].l + tr[u].r >> 1;
	pushdown(u);
	int res = LLONG_MIN;
	if(l <= mid) res = max(res, askMax(lc, l, r));
	if(r > mid) res = max(res, askMax(rc, l, r));
	return res;
}

int askMaxHis(int u, int l, int r){
	if(l <= tr[u].l && r >= tr[u].r){
		return tr[u].mxhis;
	}
	int mid = tr[u].l + tr[u].r >> 1;
	pushdown(u);
	int res = LLONG_MIN;
	if(l <= mid) res = max(res, askMaxHis(lc, l, r));
	if(r > mid) res = max(res, askMaxHis(rc, l, r));
	return res;
}

int askSum(int u, int l, int r){
	if(l <= tr[u].l && r >= tr[u].r){
		return tr[u].sum;
	}
	int mid = tr[u].l + tr[u].r >> 1;
	pushdown(u);
	int sum = 0;
	if(l <= mid) sum += askSum(lc, l, r);
	if(r > mid) sum += askSum(rc, l, r);
	return sum;
}

void solve(){
	int n, q;
	cin >> n >> q;
	for(int i = 1; i <= n; i ++){
		cin >> a[i];
    }
    build(1, 1, n);

    while(q --){
    	int op, l, r, t;
    	cin >> op >> l >> r;
    	if(op == 1){
    		cin >> t;
    		segAdd(1, l, r, t);
    	}
    	else if(op == 2){
    		cin >> t;
    		setMin(1, l, r, t);
    	}
    	else if(op == 3){
    		cout << askSum(1, l, r) << '\n';
    	}
    	else if(op == 4){
    		cout << askMax(1, l, r) << '\n';
    	}
    	else{
    		cout << askMaxHis(1, l, r) << '\n';
    	}
    }
}

signed main(){
	ios::sync_with_stdio(false);
	cin.tie(0), cout.tie(0); 

	int T = 1;
	while(T --){
		solve();
	}
	return 0;
}
running_Turtle1
关注
专栏目录
Segmentree beats!---吉如一线段树学习笔记
xiaxiaoguang_的博客
06-29 677
jry老师太牛了!! 本文为学习吉如一老师 Segmenttree beats 一文后有感而发qwq I 给定一个长度为n的数列A，接下来有m次操作： • 区间[l,r][l,r][l,r]中的所有数变成min(Ai,x)min(Ai,x)min(Ai,x) • 询问区间[l,r][l,r][l,r]中所有数的和 记录区间最大值和次大值,如果小于次大值就暴力递归即可 证明: 会发现我们每次花费O(log⁡n)O(\log n)O(logn)的时间使得两个数变得相同,因此总复杂度就是O(mlog⁡n+nlog
【学习笔记】吉司机线段树
Miniqwq的博客
08-11 3891
本文同步在洛谷博客上进行发表。 这是一篇刚开始学习线段树的小白都能看懂的良心学习笔记！ 前置知识：含有懒标记的线段树（没别的了）。 总述 什么是吉司机线段树？ 就是维护区间最值和区间历史最值的线段树，它的名字来源于吉如一老师，他在 201620162016 年发表了一篇集训队论文。 不过为啥这位老师被称为吉司机我也不知道…… 废话不多说，马上进入正题吧。 正题 例题：Luogu 6242 读完题我们发现，一般线段树题目只需要用到一个数组，而这道题用了两个，多出来了个 BBB 数组，是不是要拆成两棵树？ 通过
Segment tree Beats!.pdf
08-05
吉如一线段树~~~
浅谈区间最值操作与历史最值问题
aga28832的博客
01-05 920
浅谈树状数组与线段树：https://www.cnblogs.com/AKMer/p/9946944.html 区间最值问题 以Gorgeous Sequence为例： 对于线段树上每个结点，我们维护最大值，严格次大值，区间和，最大值个数即可。对于修改操作，分为三种情况讨论： 1、如果当前结点的最大值小于等于\(a\)的话，直接退出，因为取\(max\)操作不会对当前区间造成任何影响。 ...
【吉如一线段树】JZOJ6270. 【省赛模拟8.10】序列
Deep_Thinking的博客
08-20 1404
Description ai,n<=2e5 Solution 考虑按照答案分类，假如ddd的倍数为a[1],a[2],..a[k−1],a[k]a[1],a[2],..a[k-1],a[k]a[1],a[2],..a[k−1],a[k],那么区间被1…(a[k-1]-1),(a[2]+1)…n,(a[1]+1)…(a[n]-1)这三个区间包含的区间的答案至少为d，也就是要维护区间取MAX...
吉如一线段树1
ailiumai1945的博客
10-07 331
其实你应该在百度上搜索“吉司机线段树” 区间取最值、区间求和问题 考虑这样一种做法：线段树维护区间的最大值、次大值、最大值个数，在询问值≥最大值时直接退出，询问值\(\in(max2,max)\)时更新信息并打标记，询问值≤次大值时递归左右儿子区间。 由于取最值操作时不同数字种数减少，而递归操作的次数是与数字种数有关的，可证明没有区间加减操作时复杂度为\(O(n\log n)\)，有加减...
[JZOJ5618]【NOI2018模拟3.31】华胥梦天
Never give in.
03-31 226
DescriptionN个数的序列A 要求支持区间对一个数取min，单点做减法且对0取max，区间求和 N≤500000,Ai≤109N\leq500000,A_i\leq10^9Solution经典套路题啊（参见吉老师的SegmentTree-Beats）之前CTY讲课的时候还跟他谈笑风生来着说这不是大暴力么 结果过没多久就忘了qwq直接用线段树维护区间最大值、最大值有多少个和区间次大值
2018.07.27 bzoj3064: Tyvj 1518 CPU监控（线段树）
苟为蒟蒻又何妨
07-27 292
传送门 线段树好题。 维护区间加，区间覆盖，区间最大，区间历史最大。 这个东西在国家集训队2016论文集之《区间最值操作与历史最值问题——杭州学军中学 吉如一》中讲的已经很详细了。 简单来说是这样的： 我们先考虑没有区间覆盖的情况，如果只有区间加的话，我们维护一个标记historyhistoryhistory_addaddadd来表示当前区间在上一次区间加之后最大的历史加标记，这样的话可...
【模板】吉老师线段树
Fighting_Peter的博客
11-27 362
#define IO ios::sync_with_stdio(false);cin.tie();cout.tie(0) #pragma GCC optimize(2) #include<set> #include<map> #include<cmath> #include<stack> #include<queue> #include<random> #include<bitset> #include<string&
吉如一几何板子
02-01
2018 world final 金牌 吉老师几何板子 struct point{ db x,y; point operator + (const point &k1;) const{return (point){k1.x+x,k1.y+y};} point operator - (const point &k1;) const{return (point){x-k1.x...
区间最值操作与历史最值问题（一）
hipamp的博客
03-07 714
前言 本文主要讲解一种叫做 SegmentTree BeatsSegmentTree~BeatsSegmentTree Beats 的维护区间取最值操作的问题，以及维护区间历史最值的方法。本文参考自许多博客，以及吉老师 201620162016 年的集训队论文，会加上很多例题进行讲解QAQ。 区间最值操作 例题一 [HDU5306] Gorgeous Sequence 给出长度为 n(n≤1e6)n (n\le 1e6)n(n≤1e6) 的序列 {An}\{A_n\}{An​} 和 m
PCA（主成分分析）算法的应用场景
最新发布
huanfeng_AI的博客
11-09 107
需要注意的是，PCA并不适用于所有场景。例如，当数据之间存在非线性关系时，PCA可能无法完全揭示数据的内在结构。此外，PCA对初始变量的顺序和标签敏感，不同的变量顺序可能导致不同的主成分结果。因此，在选择数据分析方法时，需要根据具体的数据和任务需求来决定是否使用PCA。
STL set
hls0611的博客
11-09 83
练习题：P1059 [NOIP2006 普及组] 明明的随机数。
算法基础-链表
August的专栏
11-05 239
当链表的长度为偶数时，head找到的中点是靠后的，因为fast相对slow移动只快了1步，而head.next找到的中点是靠前的，因为fast相对slow移动快了2步。这2种方式寻找链表的结点主要区别是 当链表的长度为奇偶数时，找到链表中点的位置一个靠后，一个靠前。使用快慢指针寻找链表的中点有2种方式，分别是fast=head;当链表为奇数时 [1->2->3->4->5]当链表长度为奇数时，找到的中点2种方式是一样的。当链表为偶数时 [1->2->3->4]
【LeetCode】【算法】160.相交链表
passer__jw767的博客
11-05 333
Leetcode 160. 相交链表
【算法】（Python）贪心算法
yannan20190313的博客
11-04 2016
【算法】（Python）贪心算法（最大单元数，买卖股票最佳时机，最低加油次数）
洛谷 P2239 [NOIP2014 普及组] 螺旋矩阵
jzwalliser的博客
11-09 723
本文由Jzwalliser原创，发布在CSDN平台上，遵循CC 4.0 BY-SA协议。因此，若需转载/引用本文，请注明作者并附原文链接，且禁止删除/修改本段文字。
2016信息学奥林匹克国家队论文集：算法与应用探索
6. **区间最值操作与历史最值问题**（作者：吉如一，杭州学军中学）：区间操作是数据结构和算法中的常见主题，可能涉及区间动态维护、区间查询等技术，对于处理实时更新和查询的问题十分有用。 7. **再探快速傅里叶...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值