线段树，树状数组，RMQ（模板）

于 2020-08-07 08:55:34 发布
阅读量130 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46220615/article/details/107854264
版权

区间求最值

线段树模板1(51nod 1174)

const int maxn = 10005;
int line[maxn],tree[maxn<<2];
void pushup(int i){
    tree[i]=max(tree[i<<1],tree[i<<1|1]);
}
void build(int i,int l,int r)
{
    if(l==r){
        tree[i]=line[l];
        return;
    }
    int mid=(l+r)>>1;
    build(i<<1,l,mid);
    build((i<<1)+1,mid+1,r);
    pushup(i);
}
int query(int l,int r,int L,int R,int i){
    if(L>=l&&R<=r)
        return tree[i];
    int mid=(L+R)>>1;
    int maxm=0;
    if(mid>=l)
        maxm=max(maxm,query(l,r,L,mid,i<<1));
    if(mid+1<=r)
        maxm=max(maxm,query(l,r,mid+1,R,(i<<1)+1));
     return maxm;
}
int main()
{
    int n,q;cin>>n;
    for(int i=1;i<=n;i++)
       scanf("%d",&line[i]);
    build(1,1,n);
    scanf("%d",&q);
    while (q--){
        int l,r;
        scanf("%d%d",&l,&r);

       printf("%d\n",query(l+1,r+1,1,n,1));
    }
    return 0;
}



模板2（poj 3264）

const int maxn = 1e5+5;
const int Maxn=1<<19;
struct Node{
    int val,MIN;//l~r中的最值
    int l,r;
}node[Maxn];//结点
int fa[maxn]; //记录n个数的下标
void BuildTree(int i,int l,int r)
{     //从上往下迭代
    node[i].l=l;node[i].r=r;node[i].val=0,node[i].MIN=INF;//初始化
    if(l==r){
        fa[l]=i;
        return;
    }
    int mid=(l+r)>>1;
    BuildTree(i<<1,l,mid);      //左儿子建树
    BuildTree((i<<1)+1,mid+1,r);   //右儿子建树
}
void UpdateTree(int ri)
{     //从下往上更新
    if(ri==1)return;
    int fi=ri>>1;   //
    int a=node[fi<<1].val;
    int aa=node[fi<<1].MIN;

    int b=node[(fi<<1)+1].val;
    int bb=node[(fi<<1)+1].MIN;

    node[fi].val=max(a,b);   //更新父节点的max
    node[fi].MIN=min(aa,bb); //更新父节点的min

    UpdateTree(ri>>1);    //往上迭代
}
int MAX,MIN;
void Query(int i,int l,int r)
{    //从顶往下
    if(node[i].l==l&&node[i].r==r){   //区间重合，更新最值
        MAX=max(MAX,node[i].val);
        MIN=min(MIN,node[i].MIN);
        return;
    }
    int mid=(node[i].l+node[i].r)>>1;
    if(r<=mid) Query(i<<1,l,r);
    else if(l>mid) Query(i<<1|1,l,r);
    else{
        Query(i<<1,l,mid);
        Query(i<<1|1,mid+1,r);
    }
    /*
    i=i<<1;    //访问子左右区间
    if(l<=node[i].r){    // 左
        if(r<=node[i].r)Query(i,l,r);   //查询区间完全位于左侧（被左侧覆盖）
        else Query(i,l,node[i].r);
    }
    i++;
    if(r>=node[i].l){  //右
        if(l>=node[i].l)Query(i,l,r);  //被右侧覆盖
        else Query(i,node[i].l,r);
    }
     */
}
int main()
{
    int n,q;scanf("%d%d",&n,&q);
    BuildTree(1,1,n);
    for(int i=1,g;i<=n;i++){
        scanf("%d",&g);
        node[fa[i]].val=g;
        node[fa[i]].MIN=g;
        UpdateTree(fa[i]);
    }
    while (q--){
        int l,r;
        scanf("%d%d",&l,&r);
        MAX=0;MIN=INF;
        Query(1,l,r);
        printf("%d\n",MAX-MIN);
    }
    return 0;
}

RMQ模板（51nod 1174）

const int maxn = 1e6+5;
const int Maxn=1<<19;
const int mod=1e9+7;
int line[maxn][22];
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while (!isdigit(ch)){if (ch=='-') f=-1;ch=getchar();}
    while (isdigit(ch)){x=x*10+ch-48;ch=getchar();}return x*f;
}
void RMQ(int n)
{
    for(int j=1;(1<<j)<=n;j++)
        for(int i=1;i+(1<<(j-1))<=n;i++)
            line[i][j]=max(line[i][j-1],line[i+(1<<(j-1))][j-1]);
}
int main()
{
    int n=read();
    for(int i=1;i<=n;i++)
        line[i][0]=read();
        RMQ(n);
        int m=read();
        while (m--){
             int l=read();int r=read();
             l++,r++;
             int k=log2(r-l+1);
             int ans=max(line[l][k],line[r-(1<<k)+1][k]);
            printf("%d\n",ans);
        }
    return 0;
}

区间单点更新

hdu 1166 敌兵布阵

线段树模板

const int maxn = 1e5+5;
const int Maxn=1<<19;
struct NODE{
    int val,l,r;
}node[Maxn];
int fa[maxn];

void BuildTree(int i,int l,int r)
{
    node[i].l=l,node[i].r=r,node[i].val=0;
    if(l==r){
        fa[l]=i;
        return;
    }
    int mid=(l+r)>>1;
    BuildTree(i<<1,l,mid);
    BuildTree(i<<1|1,mid+1,r);
}

void UpdateTree(int ri)
{
    if(ri==1)return;
    int fi=ri>>1;
    int a=node[fi<<1].val;
    int b=node[fi<<1|1].val;
    node[fi].val=a+b;
    UpdateTree(ri>>1);
}
int res;
void Query(int i,int l,int r)
{
    if(node[i].l==l&&node[i].r==r){
        res+=node[i].val;
        return;
    }
    i=i<<1;
    if(l<=node[i].r){
        if(r<=node[i].r) Query(i,l,r);
        else Query(i,l,node[i].r);
    }
    i++;
    if(r>=node[i].l){
        if(l>=node[i].l) Query(i,l,r);
        else Query(i,node[i].l,r);
    }
}
int main()
{
    int t,cas=0,n;
    scanf("%d",&t);
    while (t--){
        cas++;
        scanf("%d",&n);
        BuildTree(1,1,n);
        for(int i=1,g;i<=n;i++){
            scanf("%d",&g);
            node[fa[i]].val=g;
            UpdateTree(fa[i]);
        }
        printf("Case %d:\n",cas);
        while (1){
           char world[10];
           int a,b;
           scanf("%s",world);
           if(world[0]=='E')break;
           scanf("%d%d",&a,&b);
           if(world[0]=='A'){
               node[fa[a]].val+=b;
               UpdateTree(fa[a]);
           }
           if(world[0]=='S'){
               node[fa[a]].val-=b;
               UpdateTree(fa[a]);
           }
           if(world[0]=='Q'){
               res=0;
               Query(1,a,b);
               printf("%d\n",res);
           }
        }
    }
    return 0;
}

线段树模板

const int maxn = 5e4+5;
const int Maxn=1<<19;
inline int lowbit(int x){return x&-x;}

int tree[maxn];
int n;

int query(int r){
    int res=0;
    while (r)res+=tree[r],r-=lowbit(r);
    return res;
}

void update(int x,int y){
    while (x<=n)tree[x]+=y,x+=lowbit(x);
}

int main()
{
    int t,cas=0;
    scanf("%d",&t);
    while (t--){
        cas++;
        memset(tree,0,sizeof(tree));
        scanf("%d",&n);
        for(int i=1,val;i<=n;i++){
            scanf("%d",&val);
            update(i,val);
        }
        char com[20];
        printf("Case %d:\n",cas);
        while (~scanf("%s",com)&&com[0]!='E'){
            int a,b;
            scanf("%d%d",&a,&b);
            if(com[0]=='A'){
                update(a,b);
            }
            else if(com[0]=='S'){
                update(a,-b);
            }
            else{
                  printf("%d\n",query(b)-query(a-1));
            }
        }
    }
}

区间更新


线段树模板

typedef long long ll;
const int maxn = 1e5+5;
const int Maxn=1<<19;

#define lson l,m,rt<<1      //宏定义
#define rson m+1,r,rt<<1|1
//poj3468 线段树区间修改与查询（模板）
ll sum[maxn<<2],add[maxn<<2],a[maxn];
struct Node{
    int l,r;
    int mid(){
        return (l+r)>>1;
    }
}tree[maxn<<2];

void Pushup(int rt){
    sum[rt]=sum[rt<<1]+sum[rt<<1|1];  //父节点等于两个子节点之和
}

void Pushdown(int rt,int m){         //从祖先往下迭代，如果父节点有lazy标记
    if(add[rt]){                     //就把其左右儿子都打上lazy标记
        add[rt<<1]+=add[rt];         //并且左右儿子的sum都应该加上其区间长度乘lazy的值
        add[rt<<1|1]+=add[rt];       //最后把父节点的lazy标记取消
        sum[rt<<1]+=add[rt]*(m-(m>>1));
        sum[rt<<1|1]+=add[rt]*(m>>1);
        add[rt]=0;
    }
}
int k=1;
void Buildtree(int l,int r,int rt)
{                               //建树应该先初始化tree
    tree[rt].l=l;               //然后从祖先往下建树，遇到叶子结点（l=r），对叶子结点（sum）赋值
    tree[rt].r=r;               //再回溯，然后就得到了每个节点（每个区间）的sum
    add[rt]=0;
    if(l==r){
       sum[rt]=a[k++];
        return;
    }
    int m=tree[rt].mid();
    Buildtree(lson);
    Buildtree(rson);
    Pushup(rt);
}

void Updatetree(int c,int l,int r,int rt)
{
    if(tree[rt].l==l&&tree[rt].r==r){    // 如果区间相等，则不必再往下更新，
        add[rt]+=c;                     //  对当前的节点打上lazy标记
        sum[rt]+=(ll)c*(r-l+1);         //  并更新该节点的sum值（区间长度 * c）
        return;                         // 然后返回
    }
    if(tree[rt].l==tree[rt].r) return;

    Pushdown(rt,tree[rt].r-tree[rt].l+1);    // 如果不，继续往下更新

    int m=tree[rt].mid();
    if(r<=m) Updatetree(c,l,r,rt<<1);         //区间判断位置
    else if(l>m) Updatetree(c,l,r,rt<<1|1);
    else{
        Updatetree(c,l,m,rt<<1);
        Updatetree(c,m+1,r,rt<<1|1);
    }

    Pushup(rt);   //往上更新
}

ll Query(int l,int r,int rt)
{
    if(tree[rt].l==l&&tree[rt].r==r) return sum[rt];

    Pushdown(rt,tree[rt].r-tree[rt].l+1);

    int m=tree[rt].mid();
    ll res=0;
    if(r<=m) res+=Query(l,r,rt<<1);
    else if(l>m) res+=Query(l,r,rt<<1|1);
    else{
        res+=Query(l,m,rt<<1);
        res+=Query(m+1,r,rt<<1|1);
    }
    return res;
}

int main()
{
    int n,m;
    while (~scanf("%d%d",&n,&m)){
        for(int i=1;i<=n;i++)
            scanf("%lld",&a[i]);
        Buildtree(1,n,1);
        while (m--){
            char ch[2];
            scanf("%s",ch);
            int a,b,c;
            if(ch[0]=='Q'){
                scanf("%d%d",&a,&b);
                printf("%lld\n",Query(a,b,1));
            }
         /*   else{
                scanf("%d%d%d",&a,&b,&c);
               Updatetree(c,a,b,1);
            } */
        }
    }
    return 0;
}
Fox...
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RMQ问题（ST表和线段树）
Rrrrya
07-14 317
RMQ问题：给定一个长度为n的区间（1-n），m次询问，每次询问[l,r]区间的极值。 ST表：一种利用dp求解区间最值的倍增算法。 关键：构造f[i][j] 数组代表的是以第i个元素为起点的长度为2^j的区间极值。 预处理： f[i][0] = s[i]，长度为1的区间的极值是元素本身。 状态转移：每个区间的长度都是2的次方，因此区间可以均分为两个等长区间，该区间的极值就等于均分的两个区间极值的极值。 f[i][j] 第一区间：从i开始，长度为2^(j-1)–>f[i][j-1] 第二区间：从i+2
--线段树--
m0_59024001的博客
07-04 133
线段树 (Segment Tree) ，一个用来处理 RMQ、RSQ 的数据结构 1. 基本思想 它的思想也是非常简单，比如有一个长度为 8 的区间，我们把它分成两个长度为 4 的区间，然后对于长度为 4 的区间再分割，每个区间记录信息（比如和） ，我们把这些区间当成一棵树上的节点，对于编号为 kkk 的区间 [l,r][l,r][l,r] ，中间点为 mid=⌊l+r2⌋mid=\lfloor \dfrac{l+r}{2} \rfloormid=⌊2l+r​⌋ ，子节点有编号为 2k2k2k 的区间 [l
线段树和RMQ解析和模板
This is bill的专属博客
07-30 1633
这几天在看RMQ的题目，但是很多RMQ的题目也可以用线段树解决。。。 看来两者
树状数组模板，RMQ模板
weixin_30945039的博客
03-05 59
昨天讲的是树状数组和RMQ，今天做了几个题总结了一下模板，至于树状数组的精髓就在这个图当中吧 rmq就是储存2^k的数据递归查询 利用二分和分治的思想： 树状数组： 1 int c[50005]; 2 int n; 3 int lowbit(int x) 4 { 5 return x&(-x); 6 } 7 void add(i...
线段树，树状数组，RMQ之间的区别与联系
不会思考的机器
04-07 1090
树状数组主要用于计算区间的和，在区间元素修改值的时候能够快速修改而不是以O(n)的复杂度进行修改； 线段树是把区间以树的形式分拆为若干个小区间，每个小区间存的都有一个值（树状数组的元素存的是区间值），所以线段树可以快速获得这个区间里面的所有的节点（元素），主要用于计算每个区间的最大最小元素（也可以快速修改区间元素的值） RMQ是用数组的形式存储元素的值，用二分的方法进行计算区间的最大最小值，所
线段树和ｒｍｑ
weixin_43331783的博客
07-19 136
题目链接： https://vjudge.net/contest/309985#problem/H 这道题用ｒｍｑ写的。看到还有线段树写法。有空来研究一下 线段树写法 https://www.cnblogs.com/blvt/p/7325968.html ｒｍｑ #include <map> #include <set> #include <stack> #in...
常用数据结构 - C语言实现
最新发布
06-18
RMQ线段树.cpp SBT.cpp SBT2.cpp splay伸展树.cpp ST表.cpp Treap.cpp Trie树.cpp 二叉堆.cpp 二维线段树.cpp 后缀数组.cpp 后缀数组模板.cpp 块状链表.cpp 左偏树 (2).cpp 左偏树.cpp 并查集.cpp 标准RMQ-ST .cpp ...
算法模板1
08-08
这可能包括数据结构如线段树、树状数组，或者特定问题的解法如DFS（深度优先搜索）、FFT（快速傅里叶变换）。算法模板帮助程序员快速地构建解决方案，避免重复造轮子，提高效率。 【线段树color the ball2】：线段...
C++一些提高+的模板
08-26
包括树剖，线段树，splay，Treap，网络流，RMQ，数论函数求值，主席树，树状数组，LCA，CRT，BSGS，树套树等模板。（注：其中的两个cdq模板都没用的，整体二分写错了，其余模板可以自行测试。 p.s.有些可能与一些已...
山东大学ACM模板_数据结构.pdf
09-30
8. **树状数组_rmq**：RMQ（Range Minimum Query）是树状数组的一个常见应用场景，用于查询区间内的最小值。 9. **线段树**：线段树是一种数据结构，用于处理区间更新和区间查询问题。它可以高效地处理一维区间上的...
线段树和rmq
blue_kid的博客
07-25 569
An easy problem AN个数排成一列，Q个询问，每次询问一段区间内的数的极差是多少。Input第一行两个整数N(1≤N≤50000),Q(1≤Q≤200000)。接下来一行N个整数a1 a2 a3 ….an,(1≤ai≤1000000000)。接下来Q行，每行两个整数L,R(1≤L≤R≤N)。Output对于每个询问输出一行，一个整数表示区间内的极差。Sample Input5 3 3
RMQ、树状数组、线段树
风轻云淡
07-16 581
1、线段树(区间求和、区间最大值、区间最小值)2、树状数组3、RMQ（区间最大值、区间最小值）
线段树之RMQ
月巴虫丰博客
05-13 847
线段树之RMQ，RMQ即区间最值查询，可以用线段树很容易实现，但是对于查询次数多的情况ST算法的效率更高。
『RMQ』解决RMQ问题的方法（一）—— 线段树
Miserable_ccf的博客
07-28 458
RMQ (Range Minimum/MaximumQuery)：     对于长度为n的数组A，回答若干询问RMQ(A,i,j)(i,j<=n-1)，返回数组A中下标在i,j范围内的最小（大）值，也就是说，RMQ问题是指求区间最值的问题。 线段树是蒟蒻最先学的维护区间性质的数据结构，对于很多新手来说是很好的选择。写起来可以递归，非常的方便。 但最大的问题就是虽然说是O(nlogn)-O...
RMQ的两种实现ST算法，和线段树
henuzxy
07-07 1134
RMQ就是一种nlog实现的区间查询最值得一种东西。 就是先划分区间，对于每一个节点存储其左右区间范围，和区间最值，我是用结构体来实现。用线段树的方法。可以参看下这个视频 https://www.bilibili.com/video/av9350697/?from=search&seid=16954174042578847354 里面讲解了线段树的实现。我们参看NYOJ 119的这个例题 链
POJ3264 RMQ的ST算法
01-23 471
RMQ问题为求区间最值的问题   线段树可以在O(logN)的时间复杂度内完成询问操作。 但是ST算法可以在常数时间内完成询问操作   ST算法：基于动态规划求区间最值的算法。 分为预处理和查询两部分 预处理：定义 F[i][j] 为从 i开始到 i+2^j-1 区间内的最值 , 我们可以讲这段2^j的区间分成两部分长度都为2^(j-1)的相同区间 区间1 为  i.....i+2
树状数组求区间最值（RMQ）
夏天的伞
11-08 1198
网上找的别人的代码，看了n遍，终于懂了些……写一下心得。 转自于：http://www.cnblogs.com/ambition/archive/2011/04/06/bit_rmq.html  转载请注明出处 lowbit函数不变，用num数组存数列的真实值，用数组tree[k]存 k-lowbit(k)+1到k区间的最值，先用num数组建立tree数组，然后修改时修改num
RMQ问题 树状数组
白菜
08-15 670
用树状数组解决RMQ问题，请看参考资料，作者用Java实现 参考资料：http://www.cnblogs.com/ljsspace/archive/2011/08/10/2133514.html 下面是仿照用C实现： #include "stdio.h" #include "string.h" #define M 100 #define LOW(p) ((p)&(-(p))) int
RMQ问题--------树状数组
weixin_43743711的博客
07-11 647
前言： 简述一下RMQ问题，就是区间和或者区间最值，当然有很多方法可以做这个RMQ问题，这里主要讲讲树状数组这个结构体来解决此问题。 最常解决两类问题： No.1 区间的查询和单点的修改 No.2 区间的最大值和最小值的差值（用两个数组来存，一个存最大值，一个存最小）,也可以是求区间最大值，最小值。 树状数组浅析 首先我们得知道，这个数据结构其实就是用数组来做的，只不过我们规范数组的用法，就成了解决问题的好帮手，上张图看看，就把此数组理解成树即可 具体说说数组的作用 NO.1 树状数组最基本的功
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值