6573: 天才的记忆 RMQ/线段树查找区间最大值

描述

 

从前有个人名叫 W and N and B，他有着天才般的记忆力，他珍藏了许多许多的宝藏。在他离世之后留给后人一个难题（专门考验记忆力的啊！），如果谁能轻松回答出这个问题，便可以继承他的宝藏。

题目是这样的：给你一大串数字（编号为 1 到 N，大小可不一定哦！），在你看过一遍之后，它便消失在你面前，随后问题就出现了，给你 M 个询问，每次询问就给你两个数字 A,B，要求你瞬间就说出属于 A 到 B 这段区间内的最大数。

一天，一位美丽的姐姐从天上飞过，看到这个问题，感到很有意思（主要是据说那个宝藏里面藏着一种美容水，喝了可以让这美丽的姐姐更加迷人），于是她就竭尽全力想解决这个问题。BUT，她每次都以失败告终，因为这数字的个数是在太多了！于是她请天才的你帮他解决。如果你帮她解决了这个问题，可是会得到很多甜头的哦！

 

输入

 

第一行一个整数 N 表示数字的个数，接下来一行为 N 个数。第三行读入一个 M，表示你看完那串数后需要被提问的次数，接下来 M 行，每行都有两个整数 A,B。

对于 30% 的数据，1≤N≤10⁴,1≤M≤100；

对于 100% 的数据，1≤N≤2×10⁵,1≤M≤10⁴ 。

 

输出

 

输出共 M 行，每行输出一个数，表示对一个问题的回答。

 

样例输入

 

6
34 1 8 123 3 2
4
1 2
1 5
3 4
2 3

样例输出

 

 

34
123
123
8

 

写了半天题解，发现RMQ是区间问题，算法其实是叫ST，算了，还是叫RMQ吧^^

RMQ板子题

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 2e5+10,inf = 0x3f3f3f3f,lgn = 20;
int f[N][lgn+5],a[N],lg[N];
int n,m,x,y;
void rmq()
{
    lg[0] = -1;
    for(int i=1;i<=n;i++)
        f[i][0] = a[i],lg[i] = lg[i>>1]+1; //lg[i]等于前一位i>>1的数值+1 
    for(int j=1;j<=lgn;j++)
        for(int i=1;i+(1<<j-1)<=n;i++)
            f[i][j] = max(f[i][j-1],f[i+(1<<j-1)][j-1]);
}
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++)scanf("%d",&a[i]);
    rmq();
    scanf("%d",&m);
    for(int i=1;i<=m;i++)
    {
        scanf("%d %d",&x,&y);
        int k = lg[y-x+1];
        int ans = max(f[x][k],f[y-(1<<k)+1][k]);
        printf("%d\n",ans);
    }
     return 0;
}

 

再来看看线段树解法：1.建树的时候线段树因为求的是区间最大值，所以父节点要这样写

t[k] = max(t[k * 2],t[k * 2 + 1]);

2.因为求的区间最大值，所以查询query函数如果当前区间不在查询区间内，那么应该返回负的极大值，如果在区间内则返回t[k]，然后递归比较左右子树区间的最大值即可

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 2e5+10,inf = 0x3f3f3f3f;
int n,m;
int c[N];
ll t[N * 4],add[N * 4],mul[N * 4]; //分别是线段树、加法、乘法 
void build(int k,int l,int r)
{
    add[k] = 0;
    mul[k] = 1; //建树顺便初始化 
    if(l == r)
    {
        t[k] = c[l];
        return;
    }
    int mid = (l + r) / 2;
    build(k * 2,l,mid);
    build(k * 2 + 1,mid + 1,r);
    t[k] = max(t[k * 2],t[k * 2 + 1]);
}
void pushdown(int k,int l,int r,int mid)
{
    //更新顺序：树、乘、加
    //左子树 = 左子树 * k层的积 + [l-mid]区间和 右子树 =  右子树 * k层的积 + [mid-r]区间和
    t[k * 2] = t[k * 2] * mul[k] + (mid - l + 1) * add[k]; 
    t[k * 2 + 1] = t[k * 2 + 1] * mul[k] + (r - mid) * add[k];
    //乘法 = 左/右儿子 * 父节点mul
    mul[k * 2] = mul[k * 2] * mul[k];
    mul[k* 2 + 1] = mul[k * 2 + 1] * mul[k];  
    //加法 = 左右儿子 * 父节点mul + 父节点add 
    add[k * 2] = add[k * 2] * mul[k] + add[k];
    add[k * 2 + 1] = add[k * 2 + 1] * mul[k] + add[k];
    mul[k] = 1;
    add[k] = 0; //重置父节点 
}
void multiply(int k,int l,int r,int a,int b,int w)
{
    if(l > b || r < a)return;
    if(l >= a && r <= b)
    {    //乘法 ： 树、乘、加都要乘w 
        mul[k] *= w;
        add[k] *= w; 
        t[k] *= w;
        return;
    }
    int mid = (l + r) / 2;
    pushdown(k,l,r,mid);
    multiply(k * 2,l,mid,a,b,w);
    multiply(k * 2 + 1,mid + 1,r,a,b,w);
    t[k] = t[k * 2] + t[k * 2 + 1];
}
void modify(int k,int l,int r,int a,int b,int w)
{
    if(l > b || r < a)return;
    if(l >= a && r <= b)
    {
        t[k] += w * (r - l + 1); //k层 的[l-r]区间和都加上w 
        add[k] += w;
        return;
    }
    int mid = (l + r) / 2;
    pushdown(k,l,r,mid);
    modify(k * 2,l,mid,a,b,w);
    modify(k * 2 + 1,mid + 1,r,a,b,w);
    t[k] = t[k * 2] + t[k * 2 + 1];
}
ll query(int k,int l,int r,int a,int b)
{
    if(l > b || r < a)return -inf;
    if(l >= a && r <= b)return t[k];
    int mid = (l + r) / 2;
    pushdown(k,l,r,mid);
    ll res = -inf;
    res = max(res,query(k * 2,l,mid,a,b));
    res = max(res,query(k * 2 + 1,mid + 1,r,a,b));
    return res;
}
int main()
{
    cin >> n;
    for(int i = 1;i <= n;i++)scanf("%d",&c[i]);
    build(1,1,n);
    int x,y,z;
    char op;
    cin >> m;
    while(m--)
    {
        scanf("%d %d",&x,&y);
        printf("%lld\n",query(1,1,n,x,y)); //查询x~y区间和 
    }
     return 0;
}