RMQ问题——线段树

最新推荐文章于 2021-08-21 23:50:01 发布
最新推荐文章于 2021-08-21 23:50:01 发布
阅读量242 收藏
点赞数 1
分类专栏： 算法笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45890533/article/details/105066988
版权

~目录~想看最终板子的可以直接跳到最后一个完整代码~

上篇说到RMQ问题可以用ST表算法处理，但需要在线修改的时候，线段树是更好的选择。
如图，很明显线段树是个二叉搜索树
在这里插入图片描述
要注意的点如下：

  1. 线段树用数组存储，数组空间简单的就一般开到原数组的4*n倍（准确的说是将n向上扩充到2的幂次方然后乘2，如5->8->16）
  2. 线段树数组存储中，某个结点的编号为n，则其左子结点编号为2 * n（表示成 n << 1）,右子节点编号为2*n+1(表示为 n << 1 | 1)
  3. 规定根节点为1

一、查询区间最值（点修改）

模板题：hihoCoder #1077 RMQ问题再临-线段树
题目大意：给出一个数组A，每次有查询或修改两种操作，此处是查询区间l到r上的最小值，或将编号为p的值改为v。
用线段树维护最值，想要改成查询最大值，只需把所有min改成max，然后把inf换成0

1.建树

void pushup(int rt) {//更新节点信息 这里以求最小值为例 可改为最大值
    Tree[rt] = min(Tree[rt << 1], Tree[rt << 1|1]);
}
void Build(int l, int r, int rt) {//[l,r]表示区间，rt表示真实存储的编号
    if (l == r) {//抵达叶结点
        Tree[rt] = A[l];
        return;
    }
    int mid = l+r>>1;
    Build(l,mid,rt << 1);//先建好左结点
    Build(mid+1,r,rt << 1 | 1);//再建好右节点
    pushup(rt);//用左右节点更新信息
}

2.更新

调用时参数为根节点编号、修改位置p、要修改成的值v、修改影响的区间（即1~n）。

void Update_point(int rt, int p, int val, int l, int r) {   //点修改
    if (l == r) {
        Tree[rt] = val;
        return;
    }
    int mid = (l+r) >> 1;
    if (p <= mid)//修改的位置如果是在左半区间，则更新左子树
        Update_point(rt<<1, p, val, l, mid);
    else Update_point(rt<<1|1, p, val, mid+1, r);//否则更新右子树
    pushup(rt);//更新当前点~
}

3.查询

难点所在，调用时参数分别为根结点、整个区间(1 ~ n)、要查询的区间(x ~ y)
ps:要查询的区间是要一直传下去不会变的~当要查询的区间子区间为l ~ r时即可返回

int query(int rt, int l, int r,int x, int y) {//从节点rt开始查询L到R的最小值/最大值/区间和 此处以最小值为例
    if (x <= l && r <= y) {//当l ~ r为要查询的区间的子区间时可直接返回当前结点的值
        return Tree[rt];
    }
    int mid = l+r >> 1;
    int ans = inf;//若求最大值，将此处改为0
    if (x <= mid) //若当前区间左端点小于等于mid，则肯定要查询左半区间
        ans = min(query(rt<<1,l,mid,x,y), ans);
    if (y > mid)//若当前区间右端点大于mid，则肯定要查询右半区间
        ans = min(query(rt<<1|1,mid+1,r,x,y), ans); 
    return ans;
}

完整代码

#include <iostream>
#include <algorithm>
using namespace std;
//定义
const int maxn = 1000005;
const int inf  = 0x3f3f3f;
int Tree[maxn<<2];
int A[maxn];
int n;
void pushup(int rt) {//向上更新节点信息 这里以求最小值为例 可改为最大值
    Tree[rt] = min(Tree[rt << 1], Tree[rt << 1|1]);
}
void Build(int l, int r, int rt) {//[l,r]表示区间，rt表示真实存储的编号
    if (l == r) {//抵达叶结点
        Tree[rt] = A[l];
        return;
    }
    int mid = l+r>>1;
    Build(l,mid,rt << 1);//先建好左结点
    Build(mid+1,r,rt << 1 | 1);//再建好右节点
    pushup(rt);//用左右节点更新信息
}
void Update_point(int rt, int p, int val, int l, int r) {   //点修改
    if (l == r) {
        Tree[rt] = val;
        return;
    }
    int mid = (l+r) >> 1;
    if (p <= mid)//修改的位置如果是在左半区间，则更新左子树
        Update_point(rt<<1, p, val, l, mid);
    else Update_point(rt<<1|1, p, val, mid+1, r);//否则更新右子树
    pushup(rt);//更新当前点~
}
int query(int rt, int l, int r,int x, int y) {//从节点rt开始查询L到R的最小值/最大值/区间和 此处以最小值为例
    if (x <= l && r <= y) {//当l ~ r为要查询的区间的子区间时可直接返回当前结点的值
        return Tree[rt];
    }
    int mid = l+r >> 1;
    int ans = inf;//若求最大值，将此处改为0
    if (x <= mid) //若当前区间左端点小于等于mid，则肯定要查询左半区间
        ans = min(query(rt<<1,l,mid,x,y), ans);
    if (y > mid)//若当前区间右端点大于mid，则肯定要查询右半区间
        ans = min(query(rt<<1|1,mid+1,r,x,y), ans); 
    return ans;
}
int main(){
    ios::sync_with_stdio(false);
    cin >> n;
    for(int i = 1; i <= n; i++) {
        cin >> A[i];
    }
    Build(1,n,1);
    int T;
    cin >> T;
    while(T--) {
        int a, b, c;
        cin >> a >> b >> c;
        if (a == 1) {
            Update_point(1,b,c,1,n);
        } else {
            int ans = query(1,1,n,b,c);
            cout << ans << endl;
        }
    }
    return 0;
}

二、区间修改（和、差、积、商等）

1.区间加操作

洛谷 P3372 【模板】线段树 1
大意为：已知一个数列，你需要进行下面两种操作：
1.将某区间每一个数加上 kk。
2.求出某区间每一个数的和。
大神题解
大神都写这么详细了我还写这个干嘛啊
算了算了自己敲一遍留着看也不错嘛
我们可以用线段树来维护区间和，以及修改的话是进行修改区间修改~这就需要一个标记数组标记，其实点修改就是区间修改的一个子问题

pushdown操作

向下更新，因为懒标记add记录了对其子结点的影响，所以需要一个向下传递影响的函数

inline void f(int rt, int l, int r, ll k) {//给当前结点加上k的影响，并更新其懒标记
    Tree[rt] += k * (r-l+1);//区间和 这里维护的是区间和，区间内每个数都加上k
    add[rt] += k;
}
void pushdown(int rt, int l, int r) {
    int mid = l+r >>1;
    f(rt<<1, l, mid, add[rt]);//更新左儿子的懒标记及其维护的值(区间和)
    f(rt<<1|1, mid+1, r, add[rt]);//更新右儿子的懒标记及其维护的值(区间和)
    add[rt] = 0;//当前懒标记置为0
}
更新区间
void Update_section(int rt, int val, int l, int r, int rl, int rr) {   //区间修改
    if (rl <= l && r <= rr) {//~当前区间为要修改的区间的子区间时直接更新其值和懒标记~
        f(rt, l, r, val);
        return;
    }
    pushdown(rt, l, r);//下一次递归前，先将当前结点的影响向下传递，然后更新当前结点
    int mid = (l+r) >> 1;
    if (rl <= mid)//修改的区间如果能影响到左半区间，则更新左子树
        Update_section(rt<<1, val, l, mid, rl, rr);
    if (rr > mid)
        Update_section(rt<<1|1, val, mid+1, r, rl, rr);//否则更新右子树
    pushup(rt);//~向上更新~
}
完整代码
#include <iostream>
#include <algorithm>
using namespace std;
//定义
typedef long long ll;
const int maxn = 1000005;
const int inf  = 0x3f3f3f;
ll add[maxn<<2];//懒标记 即对其所有子结点的影响 不包括其自身
ll Tree[maxn<<2];
ll A[maxn];
int n, T;
inline void pushup(int rt) {//向上更新节点信息 即用左孩子和右孩子的值来更新当前结点
    Tree[rt] = Tree[rt << 1]+Tree[rt << 1|1];
}
inline void f(int rt, int l, int r, ll k) {//给当前结点加上k的影响，并更新其懒标记
    Tree[rt] += k * (r-l+1);//区间和 这里维护的是区间和，区间内每个数都加上k
    add[rt] += k;
}
void pushdown(int rt, int l, int r) {
    int mid = l+r >>1;
    f(rt<<1, l, mid, add[rt]);//更新左儿子的懒标记及其维护的值(区间和)
    f(rt<<1|1, mid+1, r, add[rt]);//更新右儿子的懒标记及其维护的值(区间和)
    add[rt] = 0;//当前懒标记置为0
}
void Build(int l, int r, int rt) {//[l,r]表示区间，rt表示真实存储的编号
    add[rt] = 0;
    if (l == r) {//抵达叶结点
        Tree[rt] = A[l];
        return;
    }
    int mid = l+r>>1;
    Build(l,mid,rt << 1);//先建好左结点
    Build(mid+1,r,rt << 1 | 1);//再建好右节点
    pushup(rt);//用左右节点更新信息
}
void Update_section(int rt, int val, int l, int r, int rl, int rr) {   //区间修改
    if (rl <= l && r <= rr) {//~当前区间为要修改的区间的子区间时直接更新其值和懒标记~
        f(rt, l, r, val);
        return;
    }
    pushdown(rt, l, r);//下一次递归前，先将当前结点的影响向下传递，然后更新当前结点
    int mid = (l+r) >> 1;
    if (rl <= mid)//修改的区间如果能影响到左半区间，则更新左子树
        Update_section(rt<<1, val, l, mid, rl, rr);
    if (rr > mid)
        Update_section(rt<<1|1, val, mid+1, r, rl, rr);//否则更新右子树
    pushup(rt);//~向上更新~
}
ll query(int rt, int l, int r,int x, int y) {//从节点rt开始查询l到r的中x~y的区间和 此处以最小值为例
    if (x <= l && r <= y) {//当l ~ r为要查询的区间的子区间时可直接返回当前结点的值
        return Tree[rt];
    }
    int mid = l+r >> 1;
    ll ans = 0;
    pushdown(rt, l, r);
    if (x <= mid) //若当前区间左端点小于等于mid，则肯定要查询左半区间
        ans += query(rt<<1,l,mid,x,y);
    if (y > mid)//若当前区间右端点大于mid，则肯定要查询右半区间
        ans += query(rt<<1|1,mid+1,r,x,y); 
    return ans;
}
int main(){
    ios::sync_with_stdio(false);
    cin >> n >> T;
    for(int i = 1; i <= n; i++) {
        cin >> A[i];
    }
    Build(1,n,1);
    while(T--) {
        int a, l, r;
        cin >> a;
        if (a == 1) {
            int k;
            cin >> l >> r >> k;
            Update_section(1, k, 1, n, l, r);
        } else {
            cin >> l >> r;
            ll ans = query(1, 1, n, l, r);
            cout << ans << endl;
        }
    }
    return 0;
}

2.区间加、乘操作（较完整）

洛谷 P3373【模板】线段树 2
大神题解
这题就是在上一题的基础上变成可将某区间每个数乘/加上一个数，则需要两个懒标记数组add、mul，而在更新懒标记操作中也要注意若要更新add标记则只更新add,若要更新mul则更新mul的同时也必须更新add（add乘上k）
先乘后加！！
先乘后加！！！
先乘后加！！！
重要的事情说三遍

pushdown操作的变动

主要是f函数的变动
注意到f函数的功能是给当前结点rt的值加上上一个结点ft的所有影响（懒标记带来的），并更新当前结点ft的懒标记

inline void f(int rt, int l, int r, int ft) {//给当前结点rt加上上一个结点ft的所有影响，更新其懒标记
    //先乘后加！！更新其值
    Tree[rt] = (Tree[rt] * mul[ft]) % p;
    Tree[rt] = (Tree[rt] + add[ft] * (r-l+1)) % p;
    //更新懒标记，mul直接更新(*父结点的mul)
    mul[rt] = (mul[rt] * mul[ft]) % p;
    //add应先*父结点的mul标记,然后再+父节点的add标记！！！
    add[rt] = (add[rt] * mul[ft]) % p;
    add[rt] = (add[rt] + add[ft]) % p;
}
void pushdown(int rt, int l, int r) {
    int mid = l+r >>1;
    f(rt<<1, l, mid, rt);//更新左儿子的懒标记及其维护的值
    f(rt<<1|1, mid+1, r, rt);//更新右儿子的懒标记及其维护的值
    add[rt] = 0;
    mul[rt] = 1;//当前懒标记
}
更新操作变动（分两种更新）

加更新~

void Update_section_add(int rt,int val, int l, int r, int rl, int rr) {   //区间修改 +val
    if (rl <= l && r <= rr) {//~当前区间为要修改的区间的子区间时直接更新其值和懒标记~
        Tree[rt] =  (Tree[rt] + val * (r-l+1)) % p;//给当前结点加上val的+影响，并更新其懒标记
        add[rt] = (add[rt] + val) % p;
        return;
    }
    pushdown(rt, l, r);//下一次递归前，先将影响向下传递
    int mid = (l+r) >> 1;
    if (rl <= mid)//修改的区间如果能影响到左半区间，则更新左子树
        Update_section_add(rt<<1, val, l, mid, rl, rr);
    if (rr > mid)
        Update_section_add(rt<<1|1, val, mid+1, r, rl, rr);//否则更新右子树
    pushup(rt);//开始回溯~向上更新~
}

乘更新~乘会影响到加的懒标记！

void Update_section_mul(int rt,int val, int l, int r, int rl, int rr) {   //区间修改 *val
    if (rl <= l && r <= rr) {//~当前区间为要修改的区间的子区间时直接更新其值和懒标记~
        Tree[rt] = (Tree[rt] * val) % p;
        mul[rt] = (mul[rt] * val) % p;
        add[rt] = (add[rt] * val) % p;//very重要！！
        return;
    }
    pushdown(rt, l, r);//下一次递归前，先将影响向下传递
    int mid = (l+r) >> 1;
    if (rl <= mid)//修改的区间如果能影响到左半区间，则更新左子树
        Update_section_mul(rt<<1, val, l, mid, rl, rr);
    if (rr > mid)
        Update_section_mul(rt<<1|1, val, mid+1, r, rl, rr);//否则更新右子树
    pushup(rt);//开始回溯~向上更新~
}
完整代码
#include <iostream>
#include <algorithm>
using namespace std;
//定义
typedef long long ll;
const int maxn = 1000005;
ll add[maxn<<2];//懒标记1 即对其所有子结点的影响 不包括其自身
ll mul[maxn<<2];//懒标记2
ll Tree[maxn<<2];
ll A[maxn];
int n, T;
ll p;
inline void pushup(int rt) {//向上更新节点信息 即用左孩子和右孩子的值来更新当前结点
    Tree[rt] = Tree[rt << 1]+Tree[rt << 1|1];
}
inline void f(int rt, int l, int r, int ft) {//给当前结点rt加上上一个结点ft的k的所有影响，更新其懒标记
    //先乘后加！！
    Tree[rt] = (Tree[rt] * mul[ft]) % p;
    Tree[rt] = (Tree[rt] + add[ft] * (r-l+1)) % p;
    //mul直接更新
    mul[rt] = (mul[rt] * mul[ft]) % p;
    //加的懒标记应先*父结点的mul标记,然后再+父节点的add标记！！！
    add[rt] = (add[rt] * mul[ft]) % p;
    add[rt] = (add[rt] + add[ft]) % p;
}
void pushdown(int rt, int l, int r) {
    int mid = l+r >>1;
    f(rt<<1, l, mid, rt);//更新左儿子的懒标记及其维护的值
    f(rt<<1|1, mid+1, r, rt);//更新右儿子的懒标记及其维护的值
    add[rt] = 0;
    mul[rt] = 1;//当前懒标记
}
void Build(int l, int r, int rt) {//[l,r]表示区间，rt表示真实存储的编号
    add[rt] = 0;
    mul[rt] = 1;
    if (l == r) {//抵达叶结点
        Tree[rt] = A[l];
        return;
    }
    int mid = l+r>>1;
    Build(l,mid,rt << 1);//先建好左结点
    Build(mid+1,r,rt << 1 | 1);//再建好右节点
    pushup(rt);//用左右节点更新信息
}
void Update_section_add(int rt,int val, int l, int r, int rl, int rr) {   //区间修改 +val
    if (rl <= l && r <= rr) {//~当前区间为要修改的区间的子区间时直接更新其值和懒标记~
        Tree[rt] =  (Tree[rt] + val * (r-l+1)) % p;//给当前结点加上val的+影响，并更新其懒标记
        add[rt] = (add[rt] + val) % p;
        return;
    }
    pushdown(rt, l, r);//下一次递归前，先将影响向下传递
    int mid = (l+r) >> 1;
    if (rl <= mid)//修改的区间如果能影响到左半区间，则更新左子树
        Update_section_add(rt<<1, val, l, mid, rl, rr);
    if (rr > mid)
        Update_section_add(rt<<1|1, val, mid+1, r, rl, rr);//否则更新右子树
    pushup(rt);//开始回溯~向上更新~
}
void Update_section_mul(int rt,int val, int l, int r, int rl, int rr) {   //区间修改 *val
    if (rl <= l && r <= rr) {//~当前区间为要修改的区间的子区间时直接更新其值和懒标记~
        Tree[rt] = (Tree[rt] * val) % p;
        mul[rt] = (mul[rt] * val) % p;
        add[rt] = (add[rt] * val) % p;//very重要！！
        return;
    }
    pushdown(rt, l, r);//下一次递归前，先将影响向下传递
    int mid = (l+r) >> 1;
    if (rl <= mid)//修改的区间如果能影响到左半区间，则更新左子树
        Update_section_mul(rt<<1, val, l, mid, rl, rr);
    if (rr > mid)
        Update_section_mul(rt<<1|1, val, mid+1, r, rl, rr);//否则更新右子树
    pushup(rt);//开始回溯~向上更新~
}
ll query(int rt, int l, int r,int x, int y) {//从节点rt开始查询l到r的中x~y的区间和 此处以最小值为例
    if (x <= l && r <= y) {//当l ~ r为要查询的区间的子区间时可直接返回当前结点的值
        return Tree[rt];
    }
    int mid = l+r >> 1;
    ll ans = 0;
    pushdown(rt, l, r);
    if (x <= mid) //若当前区间左端点小于等于mid，则肯定要查询左半区间
        ans = (ans + query(rt<<1,l,mid,x,y)) % p;
    if (y > mid)//若当前区间右端点大于mid，则肯定要查询右半区间
        ans = (ans + query(rt<<1|1,mid+1,r,x,y)) % p; 
    return ans;
}
int main(){
    ios::sync_with_stdio(false);
    cin >> n >> T >> p;
    for(int i = 1; i <= n; i++) {
        cin >> A[i];
    }
    Build(1,n,1);
    while(T--) {
        int a, l, r;
        cin >> a;
        if (a == 1) {
            int k;
            cin >> l >> r >> k;
            Update_section_mul(1, k, 1, n, l, r);
        } else if(a == 2) {
            int k;
            cin >> l >> r >> k;
            Update_section_add(1, k, 1, n, l, r);
        } else {
            cin >> l >> r;
            ll ans = query(1, 1, n, l, r);
            cout << ans << endl;
        }
    }
    return 0;
}

然后~ 恭喜ac ~ 耶~！
在这里插入图片描述

余cos
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
RMQ问题之线段树（点修改）
_____
02-28 1231
上次的RMQ问题用了Sparse-Table算法来解决，然而就和之前那个最大连续和问题类似，如果要动态的修改数组的话，那么如果还用Sparse-Table算法的话，那么每次修改都要话O(nlogn)的时间重新初始化一遍，显然不太划算。那么这里就用到了另一个数据结构——线段树了。
线段树 数据结构 数 统计 RMQ
05-29
线段树 数据结构 数 统计 RMQ 可以动态查询和添加
线段树和RMQ解析和模板
This is bill的专属博客
07-30 1624
这几天在看RMQ的题目，但是很多RMQ的题目也可以用线段树解决。。。 看来两者
线段树RMQ
莱尼的博客
02-12 290
基于线段树RMQ的操作 1.RMQ查询 2.更新叶子节点
线段树之RMQ
月巴虫丰博客
05-13 799
线段树之RMQ，RMQ即区间最值查询，可以用线段树很容易实现，但是对于查询次数多的情况ST算法的效率更高。
线段树及其应用
08-16
ACM竞赛中线段树的原理及应用。如何处理区间问题，区间快速求和求RMQ。将朴素O(n)的复杂度编程O（logn）
RMQ问题求解（ST）.pptx
最新发布
02-27
线段树是一种常用的解决RMQ问题的数据结构，其查询时间复杂度为O(logn)，但需要额外的空间存储线段树。而ST（Sparse Table）算法提供了一种更为简洁的方法，它通过预处理数组，可以在常数时间内完成查询，预处理的...
第2章 RMQ问题 测试数据.rar
12-02
在信息学奥赛中，RMQ（Range Minimum Query，范围最小值查询）是一个常见的数据结构问题，它涉及高效地处理数组或序列中的区间最值查询。 RMQ问题通常出现在算法竞赛和训练中，以考察选手的数据结构设计和优化能力。...
线段树论文
07-11
线段树是一种非常重要的数据结构，在解决范围查询问题、RMQ问题等方面发挥着至关重要的作用。杨弋先生的讲稿对线段树的原理和实现进行了详细的讲解，从线段树的定义到构造、查询和修改操作都进行了深入的分析。 ...
RMQ（线段树实现）
10-26 560
T_T第一个线段树程序，还没A过题，不过也很感动， 先贴出来 //下标从0开始，输入-1 -1 结束.求每一段区间之间的最大值。 #include #include typedef struct Treenode{ int ld, rd; struct Treenode *lc, *rc; int key; }node; int mymax(int a, i
算法模板之RMQ线段树（HDU 1754 I Hate It）
摸不着脑子的博客
04-22 180
RMQ (Range Minimum/Maximum Query)问题是指：对于长度为n的数列A，回答若干询问RMQ(A,i,j)(i,j&lt;=n)，返回数列A中下标在i,j里的最小(大）值，也就是说，RMQ问题是指求区间最值的问题。模板总结归纳：const int MAXNODE = 1 &lt;&lt; 19; const int MAXN = 2e6 + 10; struct NODE...
动态区间最值（RMQ）——线段树
Happig的博客
06-07 684
建树 a数组为初始数组，tree数组为树 typedef long long ll; const int inf=0x7fffffff; const int maxn=2e5+10; int a[maxn]; int tree[maxn<<2]; 建树函数 和普通线段树唯一的区别就是更新时取左右子树的最值 void build(int i,int l,int r){ //i传入1 if(l==r){ tree[i]=a[l]; return;
线段树求RMQ
zdc_8023的博客
03-15 330
很多学校流行一种比较的习惯。老师们很喜欢询问，从某某到某某当中，分数最高的是多少。 这让很多学生很反感。 不管你喜不喜欢，现在需要你做的是，就是按照老师的要求，写一个程序，模拟老师的询问。当然，老师有时候需要更新某位同学的成绩。 Input本题目包含多组测试，请处理到文件结束。 在每个测试的第一行，有两个正整数 N 和 M ( 0 学生ID编号分别从1编到N。 第二行包含
基于线段树的RMQ
愿岁月如歌
03-31 941
const int maxn=1 int n; int dat[2&maxn-1]; void Init (int n_) {     n=1;     while(n     for(int i=0; i } void update(int k,int a) // 把第k个数的值转换为a {     k+=n-1;//叶子节点     dat[k]=a;    
『RMQ』解决RMQ问题的方法（一）—— 线段树
Miserable_ccf的博客
07-28 441
RMQ (Range Minimum/MaximumQuery)：     对于长度为n的数组A，回答若干询问RMQ(A,i,j)(i,j<=n-1)，返回数组A中下标在i,j范围内的最小（大）值，也就是说，RMQ问题是指求区间最值的问题。 线段树是蒟蒻最先学的维护区间性质的数据结构，对于很多新手来说是很好的选择。写起来可以递归，非常的方便。 但最大的问题就是虽然说是O(nlogn)-O...
线段树（二）：RMQ
主要研究图形学相关领域
08-21 487
线段树（二）：RMQ
RMQ问题 ST表 & 树状数组 线段树笔记
zhimeng_LQ的博客
05-12 282
静态区间最值问题 推荐使用ST表，倍增思想。 此类题目一般查询数量巨大，所以O(log n)不足以AC，需将查询复杂度优化为O(1) ST表模板如下： #include<bits/stdc++.h> using namespace std; const int maxn = 5e4+100; int dpMin[maxn][20],dpMax[maxn][20]; int a[maxn]; int n,q; int mn[1000006]; void RMQ() { for(int
线段树和ｒｍｑ
weixin_43331783的博客
07-19 110
题目链接： https://vjudge.net/contest/309985#problem/H 这道题用ｒｍｑ写的。看到还有线段树写法。有空来研究一下 线段树写法 https://www.cnblogs.com/blvt/p/7325968.html ｒｍｑ #include <map> #include <set> #include <stack> #in...
RMQ问题解析：线段树与ST算法
"该资源是关于RMQ问题的讲解，主要介绍了三种解决方法：朴素搜索、线段树和ST算法。RMQ问题是指在给定数列中查询区间内最小值或最大值。朴素方法时间复杂度高，线段树在处理和查询上具有更优效率，而ST算法（实际上...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

余cos

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值