A:牛牛与牛妹的RMQ | 2021牛客寒假算法基础集训营2

最新推荐文章于 2023-01-27 21:15:23 发布
最新推荐文章于 2023-01-27 21:15:23 发布
阅读量711 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jpphy0/article/details/114300213
版权

链接：https://ac.nowcoder.com/acm/contest/9982/A
时间限制：C/C++ 1秒，其他语言2秒
空间限制：C/C++ 262144K，其他语言524288K

题目描述

某天，牛妹来找牛牛学习RMQ算法(Range Minimum/Maximum Query),即区间最值查询。也就是给定一个数组区间[L,R]，查询该子区间的最大值。
假设子数组的两端点下标分别为L,R的话RMQ(L,R)就表示数组区间[L,R]的最大值。
因为牛妹学会了RMQ算法，所以牛牛准备和她玩个游戏验证她真的学会了。

牛牛有一个长度大小为n的全排列数组，即数组中的数字是1~n，且每个数字仅出现1次。
她们一共玩了m轮游戏，在每轮游戏中，牛牛都准备了k个不同的下标。
然后牛牛和牛妹各自随机选出一个下标，并且两人所选下标可以是相同的。
假设牛牛选出的下标为a，牛妹选出的下标为b的话，那么本轮游戏的得分就是RMQ(min(a,b),max(a,b))。

请你告诉牛牛，对于每轮游戏可能的得分都有哪几种情况，以及这些情况出现的概率各是多大？
在这里插入图片描述
在这里插入图片描述

分析

关键：如何遍历？

  1. 遍历所有可能区间？超时不可行。（因为：p序列有k个元素，对这k个元素排序后，容易计算出这些元素可以产生k^2个可能区间）
  2. 将k2个区间按得分进行分类，遍历所有的分类？最多2k-1个分类，可行且有效。设arr序列为（1，3， 5， 2， 4），则
    例1：如果p序列为（1，2，4，5），那么p序列的p1, p4对应arr序列的区间[1,5]，它的最大值为5(即arr3，下标i=3），因为i= 3在p序列中介于p2和p3间，借用下界的概念，最大值在p中的位置用p的下标3表示，因此有(3-1)(5-3) = 4个区间的得分为5（即arr3），出现5这个得分的次数为 2 (3-1)(5-3)=8次。到此，一个分类整体解决。
    例2：如果p序列为（1，3，4，5），那么p序列的p1, p4对应arr序列的区间[1,5]，它的最大值为5(即arr3，下标i=3），因为i= 3在p序列中等于p2，借用下界的概念，最大值在p中的位置用p的下标2表示，因此有(2-1+1)(5-3+1)-1 = 5个区间的得分为5（即arr3），出现5这个得分的次数为 2 ((2-1+1)(5-3+1)-1)=10次，此外还有[p2，p2]单独1次，共11次。
  3. 问题的主要任务就是如何找出这些分类？或者说某个得分在哪些区间是有效的？可以尝试二分搜索 和 单调栈两种方法。

思路

  1. st表存储下标，st表查询返回下标

  2. 对p序列按升序排序
    二分处理

  3. 按最大得分将整个区间二分，然后再对子区间二分处理，……，每个区间的最大值通过二分搜索确定
    单调栈

  4. 对于一个最小区间的得分，它有可能向两侧扩展从而获得这个得分的有效区间。例如：当与它相邻的区间的得分比它的得分小，就可以扩展。遍历最小的区间可以扩展出所有区间。但扩展时，左侧边界的信息出现在已遍历的区间中，而右侧边界的信息将会出现在将要遍历的区间中，即：与过去相关，与未来相关。这时单调栈发挥作用，新区间的得分比栈顶区间得分小则入栈，且扩展新区间的左边界为栈顶区间的有边界；若新区间的得分比栈顶得分大，则弹出栈顶区间，且被弹出区间的有边界为新区间的左边界。被弹出的区间是左右边界都确定的，故这个区间对应的得分出现次数是可计算的。

  5. 区间出现的次数存储在map中

  6. L==R的区间（L，R）出现的1次单独处理

代码

使用单调栈

#include <bits/stdc++.h>
using namespace std;
#define MAXN 100010
#define LOGN 20
#define LL long long
struct sRngeInP{int L, R, u, a;} r[MAXN];
int n, a[MAXN], m, k, p[MAXN<<1], st[MAXN][LOGN];
void st_init(){
    int x, y;
    for(int i = 1; i <= n; i++) st[i][0] = i;
    for(int j = 1; (1<<j) <= n; j++){
        for(int i = 1; i-1+(1<<j) <= n; i++){
            x = st[i][j-1], y = st[i+(1<<(j-1))][j-1];
            st[i][j] = a[x] > a[y] ? x : y;
        }
    }
}
int st_query(int aL, int aR){
    int j = 0, x, y;
    while((1<<(j+1) < (aR - aL + 1))) j++;
    x = st[aL][j], y = st[aR - (1<<j) + 1][j];
    return a[x] > a[y] ? x : y;
}
LL gcd(LL x, LL y){ return y ? gcd(y, x%y) : x;}
int main(){
    scanf("%d", &n);
    for(int i = 1; i <= n; i++) scanf("%d", a+i);
    n++,  a[n] = n;
    st_init();
    scanf("%d", &m);
    while(m--){
        stack<int> s;
        map<int, LL> res;
        scanf("%d", &k);
        LL tot = 1LL*k*k, tmp;        
        for(int i = 1; i <= k; i++) scanf("%d", p+i);
        k++, p[k] = n;
        sort(p+1, p+k+1, [](int x, int y){return x < y;});
        for(int i = 1; i < k; i++){
            r[i].L = i, r[i].R = i+1;
            r[i].a = st_query(p[i], p[i+1]);
            r[i].u = r[i].a == p[i] ? i : i+1;
            while(!s.empty() && a[r[i].a] > a[r[s.top()].a]){
                sRngeInP & rip = r[s.top()];
                s.pop();
                rip.R = r[i].L;
                if(s.empty()) r[i].L = rip.L;
                if(p[rip.u] == rip.a)
                    res[a[rip.a]] += 2*((rip.u-rip.L+1LL)*(rip.R-rip.u+1)-1);
                else
                    res[a[rip.a]] += 2*(rip.u-rip.L)*(rip.R-rip.u+1LL);
            }
            if(!s.empty() && a[r[i].a] == a[r[s.top()].a])
                r[s.top()].R = r[i].R;
            else{
                if(!s.empty() && a[r[i].a] < a[r[s.top()].a]){
                    r[i].L = r[s.top()].R;
                }
                s.push(i);
            }
        }
        for(int i = 1; i < k; i++) res[a[p[i]]]++;
        map<int, LL>::iterator it = res.begin();
        while(it != res.end()){
            tmp = gcd(it->second, tot);
            printf("%d %lld/%lld\n", it->first, it->second/tmp, tot/tmp);
            it++;
        }
    }
    return 0;
}

使用stl的lower_bound

#include <bits/stdc++.h>
using namespace std;
#define MAXN 100010
#define LOGN 20
#define LL long long
int n, a[MAXN], m, k, p[MAXN<<1], st[MAXN][LOGN];
LL tot, tmp;
map<int, LL> res;
queue<pair<int,int>> q;
void st_init(){
    int x, y;
    for(int i = 1; i <= n; i++) st[i][0] = i;
    for(int j = 1; (1<<j) <= n; j++){
        for(int i = 1; i-1+(1<<j) <= n; i++){
            x = st[i][j-1], y = st[i+(1<<(j-1))][j-1];
            st[i][j] = a[x] > a[y] ? x : y;
        }
    }
}
int st_query(int aL, int aR){
    int j = 0, x, y;
    while((1<<(j+1) < (aR - aL + 1))) j++;
    x = st[aL][j], y = st[aR - (1<<j) + 1][j];
    return a[x] > a[y] ? x : y;
}
LL gcd(LL x, LL y){ return y?gcd(y, x%y):x;}
void bfs(){
    LL mx_a;
    int lower;
    while(!q.empty()){
        pair<int,int> pi = q.front();
        q.pop();
        int pL = pi.first, pR = pi.second;
        if(pL >= pR) continue;
        mx_a = st_query(p[pL], p[pR]);
        lower= lower_bound(p+pL, p+pR+1, mx_a, [pL](int const mid, LL const val){
            return a[st_query(p[pL], mid)] < a[val];
        }) - p;
        if(p[lower] != mx_a){
            q.push({pL, lower-1}), q.push({lower, pR});
            res[a[mx_a]] += 2*(lower- pL)*(pR - lower+ 1LL);
        }
        else{
            q.push({pL, lower-1}), q.push({lower+1, pR});
            res[a[mx_a]] += 2*((lower- pL + 1LL)*(pR - lower+ 1) - 1);
        }
    }
}
int main(){
    scanf("%d", &n);
    for(int i = 1; i <= n; i++) scanf("%d", a+i);
    st_init();
    scanf("%d", &m);
    while(m--){
        scanf("%d", &k);
        tot = k, tot *= k, res.clear();
        for(int i = 1; i <= k; i++) scanf("%d", p+i);
        sort(p+1, p+k+1, [](int x, int y){return x < y;});
        q.push({1, k});
        bfs();
        for(int i = 1; i <= k; i++) res[a[p[i]]]++;
        map<int, LL>::iterator it = res.begin();
        while(it != res.end()){
            tmp = gcd(it->second, tot);
            printf("%d %lld/%lld\n", it->first, it->second/tmp, tot/tmp);
            it++;
        }
    }
    return 0;
}

自定义二分

#include <bits/stdc++.h>
using namespace std;
#define MAXN 100010
#define LOGN 20
#define LL long long
int n, a[MAXN], m, k, p[MAXN<<1], st[MAXN][LOGN];
LL tot, gd;
map<int, LL> res;
queue<pair<int,int>> q;
void st_init(){
    int x, y;
    for(int i = 1; i <= n; i++) st[i][0] = i;
    for(int j = 1; (1<<j) <= n; j++){
        for(int i = 1; i-1+(1<<j) <= n; i++){
            x = st[i][j-1], y = st[i+(1<<(j-1))][j-1];
            st[i][j] = a[x] > a[y] ? x : y;
        }
    }
}
int st_query(int aL, int aR){
    int j = 0, x, y;
    while((1<<(j+1) < (aR - aL + 1))) j++;
    x = st[aL][j], y = st[aR - (1<<j) + 1][j];
    return a[x] > a[y] ? x : y;
}
int search_lower(int pL, int pR, int v){
    if(pL == pR) return pR;
    if(pL+1 == pR) return st_query(p[pL], p[pL]) == v ? pL : pR;
    int pM = (pL+pR)/2;
    if(st_query(p[pL], p[pM]) == st_query(p[pM], p[pR])) return pM;
    else if(st_query(p[pL], p[pM]) == v) return search_lower(pL, pM, v);
    else return search_lower(pM, pR, v);
}
void bfs(){
    LL mx_a, lower;
    while(!q.empty()){
        pair<int,int> &pi = q.front();
        q.pop();
        int pL = pi.first, pR = pi.second;
        if(pL >= pR) continue;
        mx_a = st_query(p[pL], p[pR]);
        lower = search_lower(pL, pR, mx_a);
        if(p[upper] != mx_a){ // 区间最大值出现的位置不同
            q.push({pL, lower-1}), q.push({lower, pR}); // 两个子区间插入队列
            res[a[mx_a]] += 2*(lower - pL)*(pR - lower + 1); // 出现次数
        }
        else{
            q.push({pL, lower-1}), q.push({lower+1, pR}); // 两个子区间插入队列
            res[a[mx_a]] += 2*((lower - pL + 1)*(pR - lower + 1) - 1);// 出现次数
        }
    }
}
int main(){
    scanf("%d", &n);
    for(int i = 1; i <= n; i++) scanf("%d", a+i);
    st_init();
    scanf("%d", &m);
    while(m--){
        scanf("%d", &k);
        tot = k, tot *= k, res.clear();
        for(int i = 1; i <= k; i++) scanf("%d", p+i);
        sort(p+1, p+k+1, [](int x, int y){return x < y;});
        q.push({1, k}); // 整个区间插入队列
        bfs(); // 宽搜
        for(int i = 1; i <= k; i++) res[a[p[i]]]++; // L==R时出现1次
        map<int, LL>::iterator it = res.begin();
        while(it != res.end()){
            gd = __gcd(it->second, tot);
            printf("%d %lld/%lld\n", it->first, it->second/gd, tot/gd);
            it++;
        }
    }
    return 0;
}
jpphy0
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
Newcoder 21669 牛牛VS牛妹 (博弈+思维)
满月照亮的路
02-26 654
链接：https://ac.nowcoder.com/acm/problem/21669 来源：牛客网 题目大意 给你一个网格，有些点被#覆盖了不能再走，其他点是空地，现在牛牛和牛妹轮流开始将空地变成# 如果当前轮到的人操作之后左上角到右下角不存在通路了，当前操作的人就输了 通路只能是从左上角到右下角往右或者往下走的路径 牛牛先开始操作，如果双方都是绝顶聪明，输出最后谁赢保证一开始给你的网格...
牛牛与牛妹的游戏
m0_43449107的博客
09-25 914
链接：https://ac.nowcoder.com/acm/problem/21626 题目： 牛牛 和 牛妹 正在玩一个游戏 牛牛扔了a个b面的骰子 牛妹扔了c个d面的骰子 对于一个x面的骰子，每个面依次会写有1到x的数 一个玩家的得分就是每个骰子朝上的面的数字的总和，一个玩家能赢另一个玩家当且仅当得分严格大于另一个玩家，给你a,b,c,d,如果牛牛不可能赢，输出-1 否则假设你知道了牛牛赢了...
牛客——牛妹与牛牛的游戏
qq_45707565的博客
09-08 721
牛客——牛妹与牛牛的游戏 一天，牛妹找牛牛做一个游戏，牛妹给牛牛写了一个数字n，然后又给自己写了一个数字m，她希望牛牛能执行最少的操作将他的数字转化成自己的。 操作共有三种，如下： 1.在当前数字的基础上加一，如：4转化为5 2.在当前数字的基础上减一，如：4转化为3 3.将当前数字变成它的平方，如：4转化为16 解题思路 通过sqrt函数并四舍五入找出与之最近的数num 判断是否存在多次平方 最近的数num与m比较 汇总所需步骤step 判断哪种情况步骤较少并返回 代
牛客 - 牛牛与牛妹的约会(贪心)
Falcon的博客
02-14 692
题目链接：点击查看 题目大意：初始时给出 x 和 y 两个点，都在 x 轴上，现在要让点 x 尽可能快的去到点 y 的位置，x 可以有两种操作： 走任意时间的距离，如果花费了 time 的时间，那么可以走 time 的距离 花费一个单位时间，从点 x 闪现到点 cbrt( x ) ,cbrt是立方根 题目分析：直接贪心做就行了，每次计算出闪现后的位置，如果闪现后的位置与点 y 的距离和闪现前...
基于ST表解决RMQ(区间最值查询)问题奶牛排队—Acwing1274.奶牛排队
dp2004的博客
01-27 199
基于ST表解决RMQ(区间最值查询)问题
lca-rmq:RMQ查找LCA的算法的实现
05-15
最小公祖问题的算法。 如“重新审阅LCA问题”中所述，这将使用“范围最小查询”实现LCA。 已完成：天真RMQ，更快RMQ（使用nlogn稀疏表） 待办事项：执行±1 RMQ 天真的RMQ输出： (1(2(4..)(5..))(3(6..)(7..)))...
算法之LCA与RMQ问题1
08-08
在计算机科学领域，算法是解决问题的关键，而LCA（最近公共祖先）和RMQ（区间最值查询）是树形结构和数组处理中常见的两类问题。本文将详细介绍这两种算法及其高效解决方案。 首先，LCA（最近公共祖先）问题是在...
马拉车 tarjan算法 RMQ算法.zip_算法_算法 马拉车
09-21
本文将深入探讨三个重要的算法：Tarjan算法，RMQ（Range Minimum Query）算法，以及马拉车算法，并结合提供的压缩包文件，分析它们的基本原理、应用及实现。 首先，让我们来了解Tarjan算法。这个算法是由Robert ...
第2章 RMQ-2021-02-07.pdf
02-07
第2章 RMQ-2021-02-07.pdf
算法文档无代码RMQ&LCA问题
最新发布
04-14
算法文档无代码RMQ&LCA问题提取方式是百度网盘分享地址
贪心——牛牛VS牛妹
linjiayina的博客
01-19 752
贪心——牛牛VS牛妹 题目描述 给你一个网格，有些点被#覆盖了不能再走，其他点是空地，现在牛牛和牛妹轮流开始将空地变成#。 如果当前轮到的人操作之后左上角到右下角不存在通路了，当前操作的人就输了 通路只能是从左上角到右下角往右或者往下走的路径。 牛牛先开始操作，如果双方都是绝顶聪明，输出最后谁赢。 保证一开始给你的网格是存在一条左上角到右下角的通路的，当然，左上角与右下角都是空地。 输入描述 第一...
牛客3006D-牛牛与牛妹的约会-思维
Nothing_but_Fight的博客
02-13 1577
链接：https://ac.nowcoder.com/acm/contest/3006/D 来源：牛客网 题目描述： 牛牛在辛苦的一天的比赛之后，要去找牛妹玩，其实牛妹那天也在比赛。他为了找到牛妹，要尽快的从自己的比赛地到她的比赛地。 还记得吗，比赛地都是只在xxx轴上的，所以两个人的坐标都满足y=0。牛牛除了可以以111单位距离/单位时间的速度移动任意时间以外，还可以花费1单位时间进行闪现。每次...
D 牛牛与牛妹的约会
Luoriliming的博客
02-14 380
链接：https://ac.nowcoder.com/acm/contest/3006/D 牛牛在辛苦的一天的比赛之后，要去找牛妹玩，其实牛妹那天也在比赛。他为了找到牛妹，要尽快的从自己的比赛地到她的比赛地。 还记得吗，比赛地都是只在xx轴上的，所以两个人的坐标都满足y=0y=0。牛牛除了可以以11单位距离/单位时间的速度移动任意时间以外，还可以花费11单位时间进行闪现。每次闪现时，如果当前他...
牛牛的数列java_第八题：牛牛的作业薄上有一个长度为 n 的排列 A，这个排列包含了从1到n的n个数，但是因为一些原因，其中有一些位置（不超过 10 个）看不清了，但是牛牛记得这个数列顺序对的数量是...
weixin_29475313的博客
02-26 771
输入例子:5 54 0 0 2 0输出例子:2a[N]:保存输入数据b[N]:保存待验证的数组c[N]:保存缺失的数据vist[N]:标志哪个数据已存在index[N]:c[N]中元素的数据#include#include#includeusing namespace std;const int N=100;int a[N],b[N],visit[N];int c[15];bool judge(i...
牛牛与牛妹的约会(贪心)
Sinclair
02-13 620
链接：牛牛与牛妹的约会 牛牛去找牛妹，两人都在x轴上，牛牛除了可以以1单位距离/单位时间的速度移动任意时间以外，还可以花费1单位时间进行闪现。每次闪现时，如果当前他的坐标是x=k，他将闪现到x=k3x=\sqrt[3]{k}x=3k​的位置。请帮他算算，最短需要多少时间，他可以找到牛妹~ 输入描述: 输入数据包括多组用例，输入第一行包含一个数字T(1≤T≤5×105)(1 \leq T \leq ...
腾讯音乐秋招笔试编程三道题（2021-08-26）
试问道几许
08-27 2576
恭喜发现宝藏！微信搜索公众号【TechGuide】关注更多新鲜好文和互联网大厂的笔经面经。 作者@TechGuide【全网同名】 点赞再看，养成习惯，您动动手指对原创作者意义非凡???? 文章目录第一道：修建二叉树（100%）题目描述参考代码：第二道： 尽可能大的数（100%）题目描述参考代码第三道：方案数量（100%）题目描述参考代码 第一道：修建二叉树（100%） 题目描述 牛牛有一棵有n个节点的二叉树，其根节点为root。牛牛想修剪掉当前二叉树的叶子节点，但是牛牛不能直接删除叶子节点。他只能修剪叶子
牛牛举办了一次编程比赛,参加比赛的有3*n个选手,每个选手都有一个水平值a_i，现在要将这些选手进行组队,组成n个队伍,即每个队伍3人.该队伍的水平值等于该队伍中第二高水平值。
Hots3y的博客
11-08 675
例如： 一个队伍三个队员的水平值分别是3,3,3.那么队伍的水平值是3 一个队伍三个队员的水平值分别是3,2,3.那么队伍的水平值是3 一个队伍三个队员的水平值分别是1,5,2.那么队伍的水平值是2 为了让比赛更有看点,牛牛想安排队伍使所有队伍的水平值总和最大。 如样例所示： 如果牛牛把6个队员划分到两个队伍 如果方案为： team1:{1,2,5}, team2:{5,5,8}, 这时候水平值总...
A 牛牛与序列计数
Luoriliming的博客
02-21 2346
链接：https://ac.nowcoder.com/acm/contest/4381/A 牛牛特别羡慕那些会计数的选手,作为一个计数非常菜的选手,牛牛也想计数变得这么厉害,然而实在是太菜了。 牛牛最近又被一个简单计数题难住了,这个题目是这样的,现在有红,蓝,黑,白四种颜色的球无数种。牛牛现在想数有多少种长度为nn的序列满足红色和蓝色的球的数量都是偶数个,黑色和白色的球的数量都是奇数...
第1题：好多鱼！
weixin_33970449的博客
06-23 337
牛牛有一个鱼缸。鱼缸里面已经有n条鱼，每条鱼的大小为fishSize[i] (1 ≤ i ≤ n,均为正整数)，牛牛现在想把新捕捉的鱼放入鱼缸。鱼缸内存在着大鱼吃小鱼的定律。经过观察，牛牛发现一条鱼A的大小为另外一条鱼B大小的2倍到10倍(包括2倍大小和10倍大小)，鱼A会吃掉鱼B。考虑到这个，牛牛要放入的鱼就需要保证：1、放进去的鱼是安全的，不会被其他鱼吃掉2、这条鱼放进去也不能吃掉其他鱼鱼缸里...
倍增：C++算法教程（临时保存）
11-09
它与普通的递推算法相比，预处理时间复杂度从原来的\(O(n^2)\)降低到了\(O(n\log n)\)，查询效率保持在\(O(1)\)。教程中提到了两种不同的打表艺术——一种是伪打表，虽然能解决问题但效率较低，另一种是真打表，通过...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

jpphy0

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

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

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

打赏作者

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

抵扣说明：

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

余额充值