百度“松果“ OJ赛第一周 题解

已于 2023-03-04 16:08:16 修改
阅读量1k 收藏
点赞数 2
分类专栏： 算法题解 文章标签： 算法 数据结构
于 2023-03-04 16:07:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62953149/article/details/129332947
版权

百度"松果" OJ赛第一周 题解

第一周的周赛基本考察的都是模拟和递推递归问题，虽然不涉及很难的算法，但是还是比较考察代码能力和思维能力的。

1.数据流的中位数

题意：要求你做一个系统可以进行两个操作，第一个操作是向系统中存入一个数，第二个操作是返回当前系统中数的中位数。
思路：由于这个过程是动态进行的，所以我们如果每次都加入一个数再进行排序，时间复杂度 O ( n 2 l o g n ) O(n^2logn) O(n2logn)，无疑会超时。那么我们就需要想办法维护好中位数，考虑到是中位数，那么我们就可以把所有的数分成左右两部分进行维护。考虑到添加元素后需保持单调性，我们可以用堆来解决这个问题。手写堆较麻烦，这里就使用STL中的优先队列(priority_queue)来进行操作。
优先队列简单介绍：

#include<queue>//使用时需要加上这个头文件或者用万能头
priority_queue<int> q;//大根堆
priority_queue<int,vector<int>,greater<int> > q;//小根堆

对于维护中位数，我们可以用一个大根堆来存左边的数。（堆顶存的就是左边最大值），用一个小根堆来存右边的数。（堆顶存的就是右边的最小值）。这样如果两个堆的大小相同，那么中位数，就是两个堆顶数之和的平均值，否则，中位数就是堆的大小较大的堆顶值。
接着我们考虑添加数的操作：
第一个数直接添加到左边的堆中，接下来数的插入分为以下几种情况：
第一种两个堆的大小相同，那么我们就需要考虑插入到哪一个堆中，我们只需要去比较插入值x和左边堆的堆顶去比较即可。如果x<左边的堆顶，那么就直接插入到左边，反之插入到右边的堆中。(只有这样才能维护好中位数，即保证左边堆的最大值小于等于右边堆的最小值)。
第二种左边堆的元素比右边堆的元素多，这种情况我们就需要将值x插入到右边的堆中了，但是可以直接将x插入到右边的堆中吗？
显然是不可以的。比如如果插入值x小于左边堆的堆顶。那么如果我们直接将x插入到右边的堆中，那么是不是就不满足上面括号中的条件了。自然中位数的维护就出现了问题，所以对于这种情况，我们需要进行一个 替换，将左边堆顶的元素插入到右边堆中，然后将左边堆顶元素从左边堆中去除，再将x插入到左边的堆中，这样既可以保证操作后两边堆大小一致，且符合条件。对于x大于左边堆顶的情况，就直接插入到右边堆中就可以了。
第三种情况和上面情况类似，按照相同方式分情况处理即可。
代码：

#include<bits/stdc++.h>

using namespace std;

#define ff first
#define ss second
#define pb push_back
#define all(u) u.begin(), u.end()
#define endl '\n'

typedef pair<int, int> PII;
typedef long long LL;
const int inf = 0x3f3f3f3f;
const int N = 1e5 + 10, M = 105;
const int mod = 1e9 + 7;


void Showball() {
    LL n;
    cin>>n;
    priority_queue<LL> lq;//左边的堆，大根堆
    priority_queue<LL,vector<LL>,greater<LL>> rq;
    //右边的堆，小根堆
    while(n--){
        char op;
        LL x;
        cin>>op;
        if(op=='+') {//添加数操作
            cin>>x;
            if(lq.empty()) lq.push(x);//第一个数的插入
            else if(lq.size()==rq.size()) {//两堆大小相同
              if(x<lq.top()) lq.push(x);
              else rq.push(x);
            }
            else if(lq.size()>rq.size()){//左堆元素更多
               //x大于左堆顶，直接插入右堆
              if(x>lq.top()) rq.push(x);
              /*否则，需要将左堆堆顶加入右堆，
              并且去除，再将x插入左堆*/
              else{
                rq.push(lq.top());
                lq.pop();
                lq.push(x);
              }
            }
            else {//右堆元素数大于左端的情况
              if(x<rq.top()) lq.push(x);
              else{
                lq.push(rq.top());
                rq.pop();
                rq.push(x);
              }
            }
        }else{//输出中位数
            if(lq.size()==rq.size()) 
            cout<<(LL)(lq.top()+rq.top())/2.0<<endl;
            else if(lq.size()>rq.size()) 
            cout<<lq.top()<<endl;
            else cout<<rq.top()<<endl;
        }
    }
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    int T = 1;
    //cin>>T;
    while(T--)
        Showball();
    return 0;
}

2.碰碰车

题意：给你n个碰碰车的初始坐标和方向(1表示向右，-1表示向左)。当两个碰碰车相撞时，会立即掉头(忽略碰撞时间)，输出t秒后，每辆碰碰车的位置和方向(1表示向右，-1表示向左,0表示两车相遇)。
思路：一开始拿到这题也是感觉很绕的，这时候我们就需要画图分析样例是怎么得到的。
输入：
5 2
4 1
5 -1
7 1
2 1
6 -1
输出：
4 0
4 0
9 1
3 -1
6 1
t=0时：
在这里插入图片描述

t=1时：
在这里插入图片描述

t=2时：
在这里插入图片描述
通过以上模拟样例的过程我们可以发现：
如果两个碰碰车相向而行，并且距离1，那么他们会用0.5s相撞，然后换方向后再走0.5s。相当于位置不变，方向改变。
如果两个碰碰车相向而行，并且距离2，那么他们会用1s相撞，然后换方向。
如果对于这两种情况直接进行模拟，我们难以去模拟相撞不同的情况，所以这里需要进行一点点转变，我们将所有点的初始坐标全部扩大2倍，那么原来相向而行距离1就会变成距离2，距离2会变成距离4。这样我们就可以模拟一秒一秒的进行模拟，但是如果知识距离扩大2倍，那么原来的关系也不会成立，所以总时间也需要扩大二倍。
这样处理后我们发现问题会被简化，因为1秒后如果两车相撞，他们的位置一定是相同的，因为我们把距离扩大了2倍，原来0.5s相撞的现在会1秒后相撞。这样我们就可以每次模拟每秒后每个车的位置，然后判断如果一个位置出现了两辆车以上，那么就说明相撞了，那么我们就需要将这些车辆的方向进行改变。这里我们可以用map来存一下每个位置出现的次数。
一共t秒，每次我们都要枚举一遍n个车辆，所以时间复杂度 O ( t n ) O(tn) O(tn)。因为t和n都是1000的范围，这个复杂度是可以通过的。
代码：

#include<bits/stdc++.h>

using namespace std;

#define ff first
#define ss second
#define pb push_back
#define all(u) u.begin(), u.end()
#define endl '\n'

typedef pair<int, int> PII;
typedef long long LL;
const int inf = 0x3f3f3f3f;
const int N = 1e5 + 10, M = 105;
const int mod = 1e9 + 7;


void Showball() {
  int n,t;
  cin>>n>>t;
  t*=2;//时间扩大2倍
  map<int,int> mp;//用来存每个位置当前有多少辆车
  vector<int> a(n),v(n);
  for(int i=0;i<n;i++){
    cin>>a[i]>>v[i];
    a[i]*=2;//位置扩大2倍
    mp[a[i]]++;
  }
  while(t--){
    for(int i=0;i<n;i++){
      mp[a[i]]--;/*因为这辆车要去下一个位置，
      所以当前位置车辆减1.*/
      a[i]+=v[i];
      mp[a[i]]++;//到达位置的车辆数+1
    }

    for(int i=0;i<n;i++){
       //如果当前车辆数大于1，那么相撞了，方向改变
      if(mp[a[i]]>1) v[i]*=-1;
    }
  }
  for(int i=0;i<n;i++){
    //因为我们扩大了2倍位置，所以输出时需要还原。
    //注意如果某个位置车的数量大于1那么方向需要输出0
    cout<<a[i]/2<<" "<<v[i]*(mp[a[i]]==1)<<endl;
  }
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    int T = 1;
    //cin>>T;
    while(T--)
        Showball();
    return 0;
}

3. 移水造海

题意：给你一个宽度为n，每一列高为 h i h_i hi​的土地。
你有一个无限水桶，每次你可以选择一列土地(不能选两边),往该列土地到一桶水，一桶水，可以填一个高度单位的土地，如果倒水量高于该列土地的左边或者右边，那么水就会溢出，相当于没有到过，问你至少需要多少桶水，可以使得，这片土地变成海(即在任何位置到水都会溢出)。
思路：这题画一个图就可以分析出规律，我们接着按照样例作图。
样例：
9
4 1 2 3 6 3 2 1 3
在这里插入图片描述
我们观察这个图，可以发现对于1-7列土地，我们每列最多可以到入的水数量是由左边最高土地和右边最高土地的较小值来约束的。
比如1号土地，可以倒入的水的数量就是左边最大值4和右边最大值6取一个最小值与该土地高度的差值，即3桶，依次算一下剩下的土地。分别是：3, 2 , 1, 0, 0, 1, 2。一共就是9桶。
注意如果左右两边的最大值中较小值小于等于该列高度，那么就无法倒水。
那么我们只需要用O(n)的复杂度维护一下每列左边的最大高度，和右边的最大高度，然后直接计算即可。
时间复杂度 O ( n ) O(n) O(n)。
代码：

#include<bits/stdc++.h>

using namespace std;

#define ff first
#define ss second
#define pb push_back
#define all(u) u.begin(), u.end()
#define endl '\n'

typedef pair<int, int> PII;
typedef long long LL;
const int inf = 0x3f3f3f3f;
const int N = 1e5 + 10, M = 105;
const int mod = 1e9 + 7;


void Showball() {
  int n;
  cin>>n;
  vector<int> a(n),maxl(n),maxr(n);
  for(int i=0;i<n;i++){
    cin>>a[i];
  }
  maxl[1]=a[0];
  for(int i=2;i<n-1;i++){
    maxl[i]=max(maxl[i-1],a[i-1]);
  }
  maxr[n-2]=a[n-1];
  for(int i=n-3;i>0;i--){
    maxr[i]=max(maxr[i+1],a[i+1]);
  }
  int ans=0;
  for(int i=1;i<n-1;i++){
    //如果差值小于0，那么说明不能倒水，所以需要判断一下。
    ans+=max(0,min(maxl[i],maxr[i])-a[i]);
  }
  cout<<ans<<endl;
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    int T = 1;
    //cin>>T;
    while(T--)
        Showball();
    return 0;
}

4. 三角形的个数

题意：给你一个三角形，将其没条边进行n等分，然后依次连接，求出连接后的三角形个数。
思路：遇到这种找规律的题目，我们就需要自己先手算几个进行分析。
n=2时：
在这里插入图片描述
一共有5个三角形。
n=3时：
在这里插入图片描述

一共有13个三角形。
我们发现这些三角形有正有反。那么我们分开讨论一下。
对于正着放的三角形：
我们发现它的边长范围是：[1,n]
对于边长为 i i i的正放三角形，它在第 i i i层有1个。
那么最多可以到第n层，所以一共有 1 + 2 + . . . + n − i + 1 1+2+...+n-i+1 1+2+...+n−i+1个边长为 i i i的正放三角形。
对于前缀和，我们可以提前预处理好。
f[n]表示1-n之间所有数的和
那么总共的正三角形的个数就是 ∑ i = 1 n f [ n − i + 1 ] \sum\limits_{i=1}^n f[n-i+1] i=1∑n​f[n−i+1]
对于倒着放的三角形：
我们发现它的边长范围是：[1,n/2]
因为这个三角形是倒着放的，所以它需要预留一半的高度。
对于边长为 j j j的正放三角形，它在第 j j j层有1个。
最多到第 n − j n-j n−j层，有 ( n − j ) − j + 1 (n-j)-j+1 (n−j)−j+1个。
所以边长为 j j j的倒三角形一共有 1 + 2 + 3 + . . . ( n − 2 ∗ j + 1 ) 1+2+3+...(n-2*j+1) 1+2+3+...(n−2∗j+1)个。
那么总共的倒三角形的个数就是 ∑ j = 1 n / 2 f [ n − 2 ∗ j + 1 ] \sum\limits_{j=1}^{n/2} f[n-2*j+1] j=1∑n/2​f[n−2∗j+1]
两部分求和就是答案。
代码：

#include<bits/stdc++.h>

using namespace std;

#define ff first
#define ss second
#define pb push_back
#define all(u) u.begin(), u.end()
#define endl '\n'

typedef pair<int, int> PII;
typedef long long LL;
const int inf = 0x3f3f3f3f;
const int N = 1e5 + 10, M = 105;
const int mod = 1e9 + 7;

int f[550];//存前缀和
void Showball() {
  int n;
  cin>>n;
  int ans=0;
  for(int i=1;i<=n;i++) ans+=f[n-i+1];
  for(int j=1;j<=n/2;j++) ans+=f[n-2*j+1];
  cout<<ans<<endl;
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    int T = 1;
    cin>>T;
    //预处理前缀和
    for(int i=1;i<=500;i++) f[i]=f[i-1]+i;
    while(T--)
        Showball();
    return 0;
}

5. 硬币塔

题意：一个k级的硬币塔从下到上，由一个银币，一个k-1级硬币塔，一个k个金币，一个k-1级硬币塔，一个硬币构成。规定，0级硬币塔只有一个金币。
求出k级硬币塔从下往上数 i i i个，有几个金币。
思路:我们先梳理一下这个硬币塔的结构。
在这里插入图片描述
很明显是一个递归的结构，如果我们直接进行操作计数，也非常容易绕进去，以及出现各种各样的问题。
首先我们可以分析一下k级硬币塔的高度。定义一个数组 h [ N ] h[N] h[N],才存每级硬币塔的高度。我们已知 h [ 0 ] = 1 h[0]=1 h[0]=1,并且根据硬币塔的结构，很容易可以得到递推式： h [ i ] = 1 + h [ i − 1 ] + i + h [ i − 1 ] + 1 h[i]=1+h[i-1]+i+h[i-1]+1 h[i]=1+h[i−1]+i+h[i−1]+1。
这样我们就可以预处理出每级硬币塔的高度。然后我们就可以进行搜索了。这里为了防止超时我们可以对搜索进行一个记忆化，用一个map存一下已经搜索过的数据，这样就可以大大节省时间。
具体搜索过程可以参考代码和代码注释。
注意数据较大，开long long。
代码:

#include<bits/stdc++.h>

using namespace std;

#define ff first
#define ss second
#define pb push_back
#define all(u) u.begin(), u.end()
#define endl '\n'

typedef pair<int, int> PII;
typedef long long LL;
const int inf = 0x3f3f3f3f;
const int N = 1e5 + 10, M = 105;
const int mod = 1e9 + 7;

map<pair<LL,LL>,LL> mp;//用来存取已经搜索过的结果
LL h[M];//存取高度
void init(){//预处理硬币塔高度
    h[0]=1;
    for(int i=1;i<=40;i++){
     h[i]=1+h[i-1]+i+h[i-1]+1;      
    }
}
LL dfs(LL a,LL b){//搜索，返回a级硬币塔往上数b个的金币数
  LL bb=b;
  //如果已经搜索过，直接返回
  if(mp.count({a,b})) return mp[{a,b}];
  if(a==0) return mp[{0,b}]=1;
  /*0级硬币塔只有一个金币，
  返回并且存在map中*/
  //1个银币
  b--;
  LL ans=0;
  //a-1级硬币塔
  if(b>0){
    LL t=min(h[a-1],b);
    b-=t;
    ans+=dfs(a-1,t);
  }
  //a个金币
  if(b>0){
    LL t=min(a,b);
    b-=t;
    ans+=t;
  }
  //a-1级硬币塔
  if(b>0){
    LL t=min(h[a-1],b);
    b-=t;
    ans+=dfs(a-1,t);
  }
  //1个银币
  b--;
  return mp[{a,bb}]=ans;//返回结果，并且存在map中。
}
void Showball() {
  LL k,i;
  cin>>k>>i;
  init();
  LL ans = 0;
  if(i) ans=dfs(k,i);
  cout<<ans<<endl;
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    int T = 1;
    //cin>>T;
    while(T--)
        Showball();
    return 0;
}

码字不易，记得点赞 ^_^ 完结撒花~~~

Showball.
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
松果采摘c++
shqingzao_o的博客
10-03 513
刷题，仅供参考，出事与我无关
松果企业网站系统-Asp
06-14
松果企业网站系统是一个以asp+access进行开发的同时支持手机端与pc端的asp企业网站源码。 运行环境：标准iis环境。不支持简易版的iis； 开发工具：vscode、nodejs、npm、git； 开发语言：前端采用Javascript、Less、...
百度松果菁英班--oj赛（第四次）
忆~遂愿的博客
05-18 1038
百度松果菁英班--oj赛（第四次）
百度之星--oj
weixin_30685029的博客
05-30 154
hdu百度之星题目:http://acm.hdu.edu.cn/search.php?field=problem&key=Baidu toj百度之星题目http://acm.tju.edu.cn/toj/search_process.php 转载于:https://www.cnblogs.com/forever4444/archive/2009/05/30/1491951.ht...
百度松果人才OJ赛第一场
Leon14138的博客
04-26 886
相对马高 差分数组可以解决掉，开一个数组B,初始化为0。 每次给定（a,b），B[a+1]–,B[b]++。第k匹马的高度就是h+∑i=1kB[i]h+\sum_{i=1}^kB[i]h+i=1∑k​B[i] 但是，有一些细节需要注意。 确保a<b 马的关系可能重复，需要去重（可以用集合set完成去重） a==b忽略不处理 代码如下： #include<bits/stdc++.h> using namespace std; struct node{ int a,b; }
百度松果菁英班--oj赛（第三次）
忆~遂愿的博客
05-05 1247
百度松果菁英班--oj赛（第三次）
基于C++的松果时序数据库(pinusdb)设计源码
04-16
本源码项目是基于C++的松果时序数据库(pinusdb)设计，包含447个文件，主要使用C++编程语言。该项目是一个时序数据库，旨在提供简单、易用、高性能的数据存储和管理功能。系统支持Linux和Windows操作系统，并采用C#、...
二年级数学上册二乘法口诀（一）1数松果第二课时课件.ppt
10-19
二年级数学上册二乘法口诀（一）1数松果第二课时课件.ppt
二年级数学上册 数松果（第1课时）教案 北师大版 教案.doc
10-21
二年级数学上册 数松果（第1课时）教案 北师大版 教案.doc
松果在线报名系统-Asp
06-14
松果信息填报平台可用于各类信息的在线填报，如：新生在线报名、产品报修、活动报名、人员签到、客户反馈等，同时支持电脑端与手机端填报。平台内可创建多个不同的报名项目，各个项目具有独立的功能设置、风格设置、...
东华大学码蹄集oj赛第一周（三合一，竖直打印机，硬币塔，巨大的错误，三角形个数）
s1050712899的博客
03-05 503
mtj
单链表典型OJ题（详细图解+核心思路讲解+题目链接）
qq_54469537的博客
05-22 707
手撕单链表OJ题，最详细的图解以及核心思路讲解（快慢指针、虚拟节点等）
第一次周赛总结
BaoChengLong5的博客
02-27 117
...
Leecode---347：输出前k个高频元素（使用unordered_map）
最新发布
qq_41920323的博客
05-30 196
unordered_map实现输出前k个高频元素
算法每日一题（python,2024.05.24) day.6
L613Z的博客
05-27 436
数字比较型可以用双指针法寻找数字相同（或构成其他关系）的俩个数值（或其他类型），涉及到与数值有关的列表问题可以思考到sort()排序方法加以辅助。
算法训练营day41
stmfresher的博客
05-27 323
动态规划理论基础（主要就是确定动态规划的几个步骤）
并查集拓展（扩展域并查集）
Qlarkstar的博客
05-29 903
事实证明，扩展域并查集应该在带权并查集前面讲的，因为比较好理解，而且回过头看带权并查集可能也会更轻松一些。
24.5.26（树链剖分板子，二分+线段树）
breath_of_yuan的博客
05-27 839
思路：可看出峰值的数量是固定的，为 n/2-1，头尾不可为峰，连续俩数不能都为峰，假如我们让奇数位置的值为峰( 除了头，发现如果p的 n值在偶数位，且挨着1，是无法实现的，但其实也不难解决，将p翻转后 n下标的奇偶性就会改变( 最后输出前记得翻转 q。如果只有偶数子节点，那么0/1的选择是固定的，如果存在奇节点，所有偶节点可以取更大值，对于奇节点的选择，如果偶数个奇节点，0/1各一半，如果奇数个，多的那个取父节点的反，将奇点的 0/1 差值排个序，贪心即可。easy线段树题 建平台。补重庆科技 C 二分。
松鼠妈妈采松果晴天每天可以采20棵雨天每天只能采十颗一次他连续几天共采了180颗松果平均每天采18颗这几天中有多少天是晴天
05-31
我们设晴天采松果的天数为x，则雨天采松果的天数为(总天数-x)，因为松鼠妈妈每天可以采20棵松果，所以晴天采松果的数量为20x，雨天采松果的数量为10(总天数-x)。根据题目中的条件，可以列出如下方程： 20x + 10(总...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Showball.

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

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

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

打赏作者

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

抵扣说明：

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

余额充值