第十四届蓝桥杯省赛真题解析（含C++详细源码）

news2025/4/16 3:52:08

第十四届蓝桥杯省赛

  • 整数删除
    • 满分思路及代码
      • solution1 （40% 双指针暴力枚举）
      • solution 2（优先队列+模拟链表 AC）
  • 冶炼金属
    • 满分代码及思路
  • 子串简写
    • 满分思路及代码
      • solution 1（60% 双指针）
      • solution 2（二分 AC）
  • 岛屿个数
    • 满分代码及思路
  • 飞机降落
    • 满分思路及代码
  • 接龙数列
    • 满分思路及代码

整数删除

在这里插入图片描述
题目链接

满分思路及代码

solution1 （40% 双指针暴力枚举）

#include <iostream>
using namespace std;
const int N=5e5+10;
int n,k;
int a[N];
int main()
{
   cin>>n>>k;
   for(int i=1;i<=n;i++)
   {
     cin>>a[i];
   }
   //实际上我们并不能通过简单的排序来找到数列中最小的整数
   //因为这样会失去原来的相对位置 而导致删去后的增加操作出错
   //所以我们可以用双指针的思路来写
 
   while(k--)
 {
     int l=1;
   int r=n;
   while(l!=r)
   {
     if(a[l]<=a[r])
     {
       r--;
     }else{
       l++;
     }
   }//遍历整个数组寻找最小值
   if(l==1)
   {
     a[l+1]+=a[l];
     
   }else if(l==n)
   {
     a[l-1]+=a[l];
   }else{
     a[l+1]+=a[l];
     a[l-1]+=a[l];
   }
   //删除 覆盖掉
   for(int i=l;i<=n;i++)
   {
     a[i]=a[i+1];
   }
   n--;
}
   for(int i=1;i<=n;i++)
   {
     cout<<a[i]<<' ';
   }
   
  return 0;
}

solution 2（优先队列+模拟链表 AC）

思路参考：
在这里插入图片描述

#include <bits/stdc++.h>
using namespace std;
// 记录每个位置的数是否被删除过
bool removed[500005];
// 数据过大，爆int
#define ll long long
int main()
{
    int n, k;
    cin >> n >> k;
    // 数列，数和左右相邻的数的距离
    vector<pair<ll, pair<int, int>>> a(n);
    // 优先队列，数和下标
    priority_queue<pair<ll, int>, vector<pair<ll, int>>, greater<pair<ll, int>>> p;
    int t;
    for (int i = 0; i < n; i++)
    {
        cin >> t;
        // 相邻的数初始距离为1
        a[i] = {t, {1, 1}};
        // 数和下标压入堆
        p.push({t, i});
    }
    //查找k次
    while (k)
    {
        // 弹出第一个数
        pair<ll, int> tp = p.top();
        p.pop();
        ll value = tp.first;
        int index = tp.second;

        // 如果已经被删除过，或者被修改过，则跳过，否则删除
        if (removed[index] || a[index].first != value)
            continue;
        // 标记为已删除
        removed[index] = true;
        // 左右最近未被删除节点到自己的距离
        int l = index - a[index].second.first;
        int r = index + a[index].second.second;
        // 如果左边相邻的数存在则更新
        if (l >= 0 && !removed[l])
        {
            // 更新左边的数并压入堆
            a[l].first += value;
            p.push({a[l].first, l});
            // 如果右边的数存在，则更新左边的数到右边的距离
            if (r < n && !removed[r])
            {
                a[l].second.second += a[index].second.second;
            }
        }
        // 如果右边相邻的数存在则更新
        if (r < n && !removed[r])
        {
            // 更新右边的数并压入堆
            a[r].first += value;
            p.push({a[r].first, r});
            // 如果左边的数存在，则更新右边的数到左边的距离
            if (l >= 0 && !removed[l])
            {
                a[r].second.first += a[index].second.first;
            }
        }
        k--;
    }
    // 输出还未被删除的数
    for (int i = 0; i < n; i++)
    {
        if (!removed[i])
            cout << a[i].first << " ";
    }
    return 0;
}

冶炼金属

在这里插入图片描述

满分代码及思路

//对于这个v的范围我们怎么来确定呢
//我觉得是这样的 例如投入75个O产出3个X
//如果最好的情况即浪费的最少得时候 即V=25 当然也有小数的情况 但也就是直接相除之后向下取整就好 最后对于每一次冶炼的V取max
//最坏的情况需要考虑 还是拿上面的举例 我们可以从产出4个X所需要的V枚举到3 最后取min 但是注意此时就需要向上取整即加1；
//因为我们是在找不符合75个出3个X的临界点 即多少O出4个X

#include <bits/stdc++.h>
using namespace std;
const int N=1e4+10;
int a[N],b[N];
int n;
int maxval=1e9;
int minval=0;
int main()
{
   cin>> n;
  for(int i=0;i<n;i++)
  {
    cin>>a[i]>>b[i];
  }

 for(int i=0;i<n;i++)
 {
   maxval=min(a[i]/b[i],maxval);
   minval=max(a[i]/(b[i]+1)+1,minval);
 }

  cout<<minval<<' '<<maxval;
  return 0;
}

子串简写

在这里插入图片描述

题目链接

满分思路及代码

solution 1（60% 双指针）

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>


using namespace std;

// 双指针方法
int TwoPointers(int K, const string& S, char c1, char c2) {
    int n = S.length();
    int count = 0;
    for (int left = 0; left < n; ++left) {
        if (S[left] == c1) {
            for (int right = left + K - 1; right < n; ++right) {
                if (S[right] == c2) {
                    ++count;
                }
            }
        }
    }
    return count;
}
//首先暴力的思路类似于双指针 
//三种情况
//我们用p指针找到C1 保持c1不动移动指针q 让q不断去找c2 直到满足我们的长度我们的res++
//然后q走到最后一个c2了之后移动p 规则一样
//p q一起动
//
int main() {
    int K;
    string S;
    char c1, c2;

    // 读取输入
    cin >> K;
    cin >> S >> c1 >> c2;

    // 计算结果
    int result=TwoPointers(K, S, c1, c2);
     cout << result << endl;
    return 0;
}

solution 2（二分 AC）

#include<iostream>
#include<algorithm>
using namespace std;
int nec1[500100];
int c1dx = 0;
int c2dx = 0;
int nec2[500100];
int main()
{
    int k;
    cin >> k;
    string str;
    cin >> str;
    str = "1" + str;
    char c1, c2;
    cin >> c1 >> c2;
    for (int i = 1; i < str.length(); i++) {
        //记录c1字符所有出现的位置
        if (str[i] == c1) {
            nec1[c1dx] = i;
            c1dx++;
        }
        //记录c2字符所有出现位置
        if (str[i] == c2) {
            nec2[c2dx] = i;
            c2dx++;
        }
    }
 
    long long ans = 0;
    //枚举c1字符出现的位置
    for (int i = 0; i < c1dx; i++) {
        //二分查找c2字符出现的位置的合法位置
        auto dx = lower_bound(nec2, nec2 + c2dx, nec1[i] + k-1);
        //没有找到情况
        if (dx == nec2 + c2dx)continue;
        //找到了
        int t = dx - nec2;
        //加上总合法个数
        ans += c2dx - t;
    }
 
    cout << ans << endl;
    return 0;
}

岛屿个数

在这里插入图片描述

题目链接

满分代码及思路

在我之前的文章 搜索系列 里面可以找到详细分析

#include <bits/stdc++.h> 
using namespace std;
const int X = 50 + 10;
typedef pair<int, int> PII;
int grid[X][X];  // 使用 int 类型数组
int n, m, T;
int ans;
int s[X];
// 海的移动偏移量数组
int dx[8] = {-1,-1,-1,0,1,1,1,0};
int dy[8] = {-1,0,1,1,1,0,-1,-1};
// 陆地的移动偏移量
int DX[4] = {-1, 0, 1, 0};
int DY[4] = {0, 1, 0, -1};
bool st_land[X][X];
bool st_sea[X][X];

bool check(int x, int y) {
    if (x < n && x >= 0 && y < m && y >= 0) {
        return true;
    }
    return false;
}

// 找到了（x,y）所在的岛屿 并将该岛屿的所有点都标为了 true
void bfs_land(int u, int v) {
    queue<PII> Q;
    st_land[u][v] = true;
    PII tp = {u, v};
    Q.push(tp);
    while (!Q.empty()) {
        PII t = Q.front();
        Q.pop();
        for (int i = 0; i < 4; i++) {
            int nu = t.first + DX[i];
            int nv = t.second + DY[i];
            if (check(nu, nv) && grid[nu][nv] == 1 && !st_land[nu][nv]) {
                st_land[nu][nv] = true;
                Q.push({nu, nv});
            }
        }
    }
}

void bfs_sea(int x, int y) {
    queue<PII> q;
    PII tmp = {x, y};
    q.push(tmp);
    st_sea[x][y] = true;
    while (!q.empty()) {
        PII p = q.front();
        q.pop();
        for (int i = 0; i < 8; i++) {  // 枚举一下海的方向  
            int nx = p.first + dx[i];
            int ny = p.second + dy[i];
            if (!check(nx, ny) || st_sea[nx][ny]) {
                continue;
            }
            if (grid[nx][ny] == 0) {
                st_sea[nx][ny] = true;
                q.push({nx, ny});
            } else if (grid[nx][ny] == 1 && !st_land[nx][ny]) {
                ans++;
                bfs_land(nx, ny);  // 如果发现寻找外海的过程中发现了陆地 说明属于新的外岛那么需要找到与他相连的全部陆地
            }
        }
    }
}



int main() {
    cin >> T;
    while (T--) {
        cin >> n >> m;
        ans = 0;  // 每次都需要重置一下
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                st_sea[i][j] = st_land[i][j] = false;
            }
        }
        for (int i = 0; i < n; i++) {
            string s;
            cin >> s;
            for (int j = 0; j < m; j++) {
                grid[i][j] = s[j] - '0';  // 将字符转化成数字存进去
            }
        }
        bool has_sea = false;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (i == 0 || i == n - 1 || j == 0 || j == m - 1) {
                    if (!st_sea[i][j] && grid[i][j] == 0) {  // 当前的这个点是海并且是没有被标记过
                        has_sea = true;
                        bfs_sea(i, j);
                    }
                }
            }
        }
        // 判断全是陆地的特例（只有一个大岛）
        if (!has_sea) {
            ans = 1;
        }
        cout << ans << endl;
    }
    return 0;
}

飞机降落

在这里插入图片描述
题目链接

满分思路及代码

思路直接去看我之前的文章就好：搜索系列
非常详细具体
视频讲解：非常牛逼

#include <bits/stdc++.h>
using namespace std;
const int N =10+9;//防止越界
int n;//有多少架飞机
//int T,D,L;//分别表示降落时刻，能盘旋的时间，降落的时间
//考虑到这题这三个数据可以代表一架飞机的属性 可以考虑采用结构体来实现
 struct plane{
int t;
int d;
int l;
}p[N];
bool s[N];//每架飞机的状态
//我们需要知道几架飞机成功降落 和前一架飞机降落的时间
bool dfs(int x,int time)
{
    if(x>=n)
    {
        return true;
    }//递归出口
    //枚举每种降落顺序
    for(int i=0;i<n;i++)
        {
            if(!s[i])//这架飞机没有安排过
            {
                s[i]=true;
                if(p[i].t+p[i].d<time)//燃尽了也没等到前一架飞机降落完毕
                {
                    //回溯
                    s[i]=false;
                    return false;
                }
                int next=max(p[i].t,time)+p[i].l;//核心 两种情况的综合
                //即一来就可以落 和 需要等前一架降落完毕再落
                if(dfs(x+1,next))
                {
                    return true;//后续的飞机都可以顺利降落
                }
                s[i]=false;
            }
        }
    return false;//所有降落方案都不能成功降落；
    
}
int main()
{
    int T;//测试的组数
    cin>>T;
    while(T--)
        {
            cin>>n;
    for(int i=0;i<n;i++)
        {
            cin>>p[i].t>>p[i].d>>p[i].l;
        }
            if(dfs(0,0))
            {
                cout<<"YES"<<endl;
            }else{
                cout<<"NO"<<endl;
            }
            for(int i=0;i<n;i++)
                {
                    s[i]=false;
                }
        }
    return 0;
    
}

接龙数列

在这里插入图片描述

题目链接

满分思路及代码

其实我们需要转化题目所问的问题
题目问的是 最少需要删除几个字符或者说数字 等价于求数列最长是多少 ——最长子序列问题
思路参考:视频讲解

#include <iostream>
using namespace std;
const int N = 1e5;
int a[N]; //也可以使用vector,但在效率上会有损失
int dp[10];//全局变量，全部默认初始化为0
int main()
{
int n;
cin >> n;
for (int i = 0;i < n;i++)
{
cin >> a[i];
}
//拆分每一个数，取出首位数字和末位数字
int front, tail;
for (int i = 0;i < n;i++)
{
int cur = a[i];
tail =cur % 10;
front =tail;
while (cur)
{
front = cur%10;
cur= cur / 10;
}
dp[tail] = dp[tail] > dp[front] + 1 ? dp[tail] : dp[front ]+ 1;
}
//找最大的dp数组元素值
int maxLen = 0;
for (int i = 0;i < 10;i++)
{
if (dp[i] > maxLen)
maxLen = dp[i];
}
cout << n - maxLen << endl;
return 0;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2330180.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

OpenAI即将开源！DeepSeek“逼宫”下，AI争夺战将走向何方？

OpenAI即将开源！DeepSeek“逼宫”下，AI争夺战将走向何方？

OpenAI 终于要 Open 了。 北京时间 4 月 1 日凌晨&#xff0c;OpenAI 正式宣布&#xff1a;将在未来几个月内开源一款具备推理能力的语言模型&#xff0c;并开放训练权重参数。这是自 2019 年 GPT-2 部分开源以来&#xff0c;OpenAI 首次向公众开放核心模型技术。 【图片来源于…
阅读更多...
mysql 8.0.27-docker

mysql 8.0.27-docker

安装 可以略过本步 https://dev.mysql.com/downloads/https://dev.mysql.com/downloads/ 镜像查询与安装 先查询&#xff1a; docker search mysql 明显会报错 Error response from daemon: Get "https://index.docker.io/v1/search?qmysql&n25": dial tcp…
阅读更多...
使用NVM下载Node.js管理多版本

使用NVM下载Node.js管理多版本

提示&#xff1a;我解决这个bug跟别人思路可能不太一样&#xff0c;因为我是之前好用&#xff0c;换个项目就不好使了&#xff0c;倦了 文章目录 前言项目场景一项目场景二解决方案&#xff1a;下载 nvm安装 nvm重新下载所需Node 版本nvm常用命令 项目结构说明 前言 提示&…
阅读更多...
Linux——文件（2）文件系统

Linux——文件（2）文件系统

我们知道&#xff0c;文件在没有被打开时是放在磁盘中的&#xff0c;通常我们未打开的文件数量要远远大于打开的文件数量&#xff0c;而且我们要想打开一个文件&#xff0c;首先需要知道文件在磁盘的位置才能打开&#xff0c;但问题是&#xff0c;面对磁盘中成百上千个文件&…
阅读更多...
蓝桥杯 web 水果拼盘 （css3）

蓝桥杯 web 水果拼盘 （css3）

做题步骤&#xff1a; 看结构&#xff1a;html 、css 、f12 分析: f12 查看元素&#xff0c;你会发现水果的高度刚好和拼盘的高度一样&#xff0c;每一种水果的盘子刚好把页面填满了&#xff0c;所以咱们就只要让元素竖着排列&#xff0c;加上是竖着&#xff0c;排不下的换行…
阅读更多...
【eNSP实验】RIP协议

【eNSP实验】RIP协议

RIP协议介绍 RIP&#xff08;路由信息协议&#xff09;是一种基于距离向量的内部网关协议&#xff0c;适用于小型网络。它通过跳数&#xff08;最多15跳&#xff09;衡量路径成本&#xff0c;定期与相邻路由器交换路由表。RIPv1使用广播更新且不支持子网&#xff0c;RIPv2新增…
阅读更多...
JAVA反序列化深入学习（十三）：Spring2

JAVA反序列化深入学习（十三）：Spring2

让我们回到Spring Spring2 在 Spring1 的触发链上有所变换&#xff1a; 替换了 spring-beans 的 ObjectFactoryDelegatingInvocationHandler使用了 spring-aop 的 JdkDynamicAopProxy &#xff0c;并完成了后续触发 TemplatesImpl 的流程 简而言之&#xff0c;换了一个chain&am…
阅读更多...
Matlab:三维绘图

Matlab:三维绘图

目录 1.三维曲线绘图命令&#xff1a;plot3 实例——绘制空间直线 实例——绘制三角曲线 2.三维曲线绘图命令&#xff1a;explot3 3.三维网格命令&#xff1a;mesh 实例——绘制网格面 实例——绘制山峰曲面 实例——绘制函数曲线 1.三维曲线绘图命令&#xff1a;plot3 …
阅读更多...
学透Spring Boot — 016. 魔术师 - Spring MVC Conversion Service 类型转换

学透Spring Boot — 016. 魔术师 - Spring MVC Conversion Service 类型转换

本文是我的《学透Spring Boot》专栏的第16篇文章&#xff0c;了解更多请移步我的专栏&#xff1a; Postnull的专栏《学透Spring Boot》 目录 遇到问题 日期格式的转换 实现需求 创建转换器 注册转换器 编写Controller 访问测试 存在的问题 解决问题 源码分析 总结 …
阅读更多...
Spring Boot开发三板斧：高效构建企业级应用的核心技法

Spring Boot开发三板斧：高效构建企业级应用的核心技法

&#x1f9d1; 博主简介&#xff1a;CSDN博客专家、CSDN平台优质创作者&#xff0c;获得2024年博客之星荣誉证书&#xff0c;高级开发工程师&#xff0c;数学专业&#xff0c;拥有高级工程师证书&#xff1b;擅长C/C、C#等开发语言&#xff0c;熟悉Java常用开发技术&#xff0c…
阅读更多...
手搓多模态-03 顶层和嵌入层的搭建

手搓多模态-03 顶层和嵌入层的搭建

声明&#xff1a;本代码非原创&#xff0c;是博主跟着国外大佬的视频教程编写的&#xff0c;本博客主要为记录学习成果所用。 我们首先开始编写视觉模型这一部分&#xff0c;这一部分的主要功能是接收一个batch的图像&#xff0c;并将其转化为上下文相关的嵌入向量&#xff0c;…
阅读更多...
【经验分享】将qt的ui文件转换为py文件

【经验分享】将qt的ui文件转换为py文件

&#x1f31f; 嗨&#xff0c;我是命运之光&#xff01; &#x1f30d; 2024&#xff0c;每日百字&#xff0c;记录时光&#xff0c;感谢有你一路同行。 &#x1f680; 携手启航&#xff0c;探索未知&#xff0c;激发潜能&#xff0c;每一步都意义非凡。 首先简单的设计一个U…
阅读更多...
探秘JVM内部

探秘JVM内部

在我们编写Java代码&#xff0c;点击运行后&#xff0c;会发生什么事呢&#xff1f; 首先&#xff0c;Java源代码会经过Java编译器将其编译成字节码&#xff0c;放在.class文件中 然后这些字节码文件就会被加载到jvm中&#xff0c;然后jvm会读取这些文件&#xff0c;调用相关…
阅读更多...
在HarmonyOS NEXT 开发中，如何指定一个号码，拉起系统拨号页面

在HarmonyOS NEXT 开发中，如何指定一个号码，拉起系统拨号页面

大家好&#xff0c;我是 V 哥。 《鸿蒙 HarmonyOS 开发之路 卷1 ArkTS篇》已经出版上市了哈&#xff0c;有需要的朋友可以关注一下&#xff0c;卷2应用开发篇也马上要出版了&#xff0c;V 哥正在紧锣密鼓的写鸿蒙开发实战卷3的教材&#xff0c;卷3主要以项目实战为主&#xff0…
阅读更多...
利用空间-运动-回波稀疏性进行5D图像重建，以实现自由呼吸状态下肝脏定量磁共振成像（MRI）的加速采集|文献速递--深度学习医疗AI最新文献

利用空间-运动-回波稀疏性进行5D图像重建，以实现自由呼吸状态下肝脏定量磁共振成像（MRI）的加速采集|文献速递--深度学习医疗AI最新文献

Title 题目 5D image reconstruction exploiting space-motion-echo sparsity foraccelerated free-breathing quantitative liver MRI 利用空间-运动-回波稀疏性进行5D图像重建&#xff0c;以实现自由呼吸状态下肝脏定量磁共振成像&#xff08;MRI&#xff09;的加速采集 …
阅读更多...
ZKmall开源商城B2B2C电商用户隐私信息保护策略：数据脱敏全链路实践

ZKmall开源商城B2B2C电商用户隐私信息保护策略：数据脱敏全链路实践

随着业务的不断拓展和用户规模的持续扩大&#xff0c;用户隐私信息的保护也面临着前所未有的挑战。下面将深入探讨ZKmall开源商城在数据脱敏方面的实践&#xff0c;以及针对B2B2C电商用户隐私信息的具体保护策略。 数据脱敏&#xff0c;又称数据去标识化或数据匿名化&#xff0…
阅读更多...
Pgvector的安装

Pgvector的安装

Pgvector的安装 向量化数据的存储&#xff0c;可以为 PostgreSQL 安装 vector 扩展来存储向量化数据 注意&#xff1a;在安装vector扩展之前&#xff0c;请先安装Postgres数据库 vector 扩展的步骤 1、下载vs_BuildTools 下载地址&#xff1a; https://visualstudio.microso…
阅读更多...
Django接入 免费的 AI 大模型——讯飞星火（2025年4月最新！！！）

Django接入 免费的 AI 大模型——讯飞星火（2025年4月最新！！！）

上文有介绍deepseek接入&#xff0c;但是需要 付费&#xff0c;虽然 sliconflow 可以白嫖 token&#xff0c;但是毕竟是有限的&#xff0c;本文将介绍一款完全免费的 API——讯飞星火 目录 接入讯飞星火&#xff08;免费&#xff09; 测试对话 接入Django 扩展建议 接入讯飞星火…
阅读更多...
路由器学习

路由器学习

路由器原理 可以理解成把不同的网络打通&#xff0c;实现通信的设备。比如家里的路由器&#xff0c;他就是把家里的内网和互联网&#xff08;外网&#xff09;打通。 分类 1.&#xff08;按应用场景分类&#xff09; 路由器分为家用的&#xff0c;企业级的&#xff0c;运营…
阅读更多...
UE5学习记录part14

UE5学习记录part14

第17节 enemy behavior 173 making enemies move: AI Pawn Navigation 按P查看体积 So its very important that our nav mesh bounds volume encompasses all of the area that wed like our 因此&#xff0c;我们的导航网格边界体积必须包含我们希望 AI to navigate in and …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023