24.第12届蓝桥杯省赛真题题解

A.空间（100%）

计算机存储单位计算

1TB=2^10 GB

1GB=2^10 MB

1MB=2^10 KB

1KB=2&10 B

1B=8 bit(bit位二进制的最小的存储单位)

#include <iostream>
#include <cmath>

using namespace std;
//2^28B  2^2

int main(){
    std::ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    cout<<(int)pow(2,26)<<endl;
    return 0;
}

B.卡片（100%）

#include <iostream>
#include <cmath>

using namespace std;
const int N=20;
int cnt[N];
int main(){ 
	std::ios::sync_with_stdio(false);
	cin.tie(0);cout.tie(0);
	int n=2021;
	for(int i=0;i<=9;i++){
		cnt[i]=n;
	}
	bool flag=false;
	int x;
	for(x=1;;x++){
		int t=x;
		while(t){
			//123
			int num=t%10;
			if(--cnt[num]<0){
				flag=true;
				break;
			}
			t=t/10;
		}
		if(flag) break;
	}
	cout<<x-1<<endl;
	return 0;
}

C.直线（100%）

根据y=kx+b 俩个点确定唯一的一个（k,b）对 放在set中去重加 输出个数
#include <iostream>
#include <cmath>
#include <set>
using namespace std;

int main(){
    std::ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    set<pair<double,double>> st;
    for(int x1=0;x1<=19;x1++){
        for(int y1=0;y1<=20;y1++){
            for(int x2=x1+1;x2<=19;x2++){
                for(int y2=0;y2<=20;y2++){
                    double k=(y2-y1)*1.0/(x2-x1);
                    double b=(y1 * x2 - y2 * x1) *1.0/ (x2 - x1);
                    st.insert({k,b});
                }
            }
        }
    }
    cout<<st.size()+20<<endl;
    return 0;
}

D.物品摆放（100%）

枚举3个位置的值

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

#include <iostream>
#include <vector>
#define int long long 
using namespace std;
int n=2021041820210418,ans;
vector<int> vec;
signed main(){ 
	std::ios::sync_with_stdio(false);
	cin.tie(0);cout.tie(0);
	for(int i=1;i*i<=n;i++){
		if(n%i==0){//是因子 16
			vec.push_back(i);//2
			if(i!=n/i) vec.push_back(n/i);//8
		}
	}
	for(int i=0;i<vec.size();i++){
		for(int j=0;j<vec.size();j++){
			for(int k=0;k<vec.size();k++){
				if(vec[i]*vec[j]*vec[k]==n){
					ans++;
				}
			}
		}
	} 
	cout<<ans<<endl;
	return 0;
}

E.路径（100%）

Dijkstra(单源最短路)

时间复杂度O(n^2)

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

不用邻接表邻接矩阵版本

#include <iostream>
#include <climits>
#include <cmath>
using namespace std;
const int N=2021;
int n=2021,mindis[N],st=1,t=2021;
bool vis[N];
int gcd(int a,int b){
    return b==0? a:gcd(b,a%b);
}
int lcm(int a,int b){
    return a/gcd(a,b)*b;
}
void dijkstra(int s){
    mindis[s]=0;
    for(int i=1;i<=n;i++){
        int mi=INT_MAX,miId=0;
        for(int j=1;j<=n;j++){
            if(!vis[j]&&mi>mindis[j]){
                mi=mindis[j];
                miId=j;
            }
        }
        vis[miId]=1;
        for(int i=1;i<=n;i++){
            if(miId-i!=0&&abs(miId-i)<=21&&!vis[i]){
                int id=i,w=lcm(miId,id);
                if(mi+w<mindis[id]){
                    mindis[id]=mi+w;
                }
            }
        }
    }
}

int main(){
    std::ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    for(int i=1;i<=n;i++) mindis[i]=INT_MAX;
    dijkstra(st);
    cout<<mindis[t]<<endl;
    return 0;
}

邻接表版本

#include <iostream>
#include <vector>
#include <cmath>
#include <climits>
#define int long long

using namespace std;
const int N=3e3+10,INF=INT_MAX;
vector<pair<int,int>> g[N];
int n=2021,mindis[N],st=1,t=2021;
bool vis[N];
//mindis[i]-->起点到i点的最短路 
//6 12 
int gcd(int a,int b){
	return b==0?a:gcd(b,a%b);
}
int lcm(int a,int b){
	return a/gcd(a,b)*b;
}
void dijkstra(int s){
	mindis[s]=0;
	for(int i=1;i<=n;i++){
		int mi=INT_MAX,miId=0;
		//在集合中找到未被标记过的最小值，即起点到该点的最短路 
		for(int j=1;j<=n;j++){
			if(!vis[j]&&mi>mindis[j]){
				mi=mindis[j];
				miId=j;
			}
		}
		vis[miId]=1;
		//以miId位中转点,访问miId未被标记过的邻接点，更新集合 
		for(int j=0;j<g[miId].size();j++){
			int id=g[miId][j].first,w=g[miId][j].second;
			if(!vis[id]&&mindis[id]>mi+w){
				mindis[id]=mi+w;
			}
		}
	}
} 
signed main(){ 
	std::ios::sync_with_stdio(false);
	cin.tie(0);cout.tie(0);
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++){
			if(i!=j&&abs(i-j)<=21){
                //无向图，双向连边
				g[i].push_back({j,lcm(i,j)});g[j].push_back({i,lcm(i,j)});
			}
		}
	}
	fill(mindis+1,mindis+n+1,INF);
	dijkstra(st);
	cout<<mindis[t];
	return 0;
}

Floyd(多元最短路)

三层for循环 时间复杂度O(n^3)
#include <iostream>
#include <vector>
#include <cmath>
#include <climits>
#define int long long

using namespace std;
const int N=3e3+10,INF=INT_MAX;
int n=2021,mindis[N][N],st=1,t=2021;
bool vis[N];
//mindis[i][j]-->起点i到j点的最短路 
//6 12 
int gcd(int a,int b){
	return b==0?a:gcd(b,a%b);
}
int lcm(int a,int b){
	return a/gcd(a,b)*b;
}
void floyd(){
    //枚举中转站
	for(int k=1;k<=n;k++){
        //枚举起点
		for(int i=1;i<=n;i++){
            //枚举终点
			for(int j=1;j<=n;j++){
                //判断是否又连边
				if(mindis[i][k]!=INF&&mindis[k][j]!=INF){
                    //判断是否需要更新mindis集合
					if(mindis[i][k]+mindis[k][j]<mindis[i][j]){
						mindis[i][j]=mindis[i][k]+mindis[k][j];
					}
				}
			}
		}
	}
}
signed main(){ 
	std::ios::sync_with_stdio(false);
	cin.tie(0);cout.tie(0);
	fill(mindis[0],mindis[0]+N*N,INF);
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++){
			if(i!=j&&abs(i-j)<=21){
				mindis[i][j]=mindis[j][i]=lcm(i,j);
			}
		}
	}
	floyd();
	cout<<mindis[st][t]<<endl;
	return 0;
}

F.时间显示（100%）

#include <iostream>
#include <algorithm>
#define int long long
using namespace std;
int HH,MM,SS,x1,x2;
const int DAY=24*60*60,H=60*60,M=60;
//1618708103123
//449641:08:23
signed main(){ 
	std::ios::sync_with_stdio(false);
    	cin.tie(0);cout.tie(0);
	int n;cin>>n;//1618708103123
	n=n/1000;//46863
	HH=n/H%24;//13
	x1=n%H;//63
	MM=x1/M;//1
	x2=x1%M;//3
    SS=x2;
    printf("%02ld:%02ld:%02ld\n",HH,MM,SS);
    return 0;
}

G.砝码称重（10%）

搜索+回溯

#include <iostream>
#include <vector>
#include <cmath>
#include <climits>
#include <set>
#define int long long

using namespace std;
const int N=1e5+10;
int a[N],n; 
bool vis[N];
set<int> st; 
void dfs(int sum,int depth){
	//3
	//1 4 6
	//insert   d 1 sum 1
	//insert 1 d 2 sum 5
	//insert 5 d 3 sum 10
	//insert 10d 4 sum  
	if(depth>=2) st.insert(sum);
	if(depth==n+1) return;
	
	
	for(int i=1;i<=n;i++){
		if(!vis[i]){
			vis[i]=1;
			dfs(sum+a[i],depth+1);
			dfs(abs(sum-a[i]),depth+1);
			vis[i]=0;
		}
	}
}
signed main(){ 
	std::ios::sync_with_stdio(false);
	cin.tie(0);cout.tie(0);
	cin>>n;
	for(int i=1;i<=n;i++){
		cin>>a[i];
	}
	dfs(0,1);
	if(st.find(0)!=st.end()) st.erase(0);
	cout<<st.size()<<endl;
	return 0;
}

H.杨辉三角（40%）

#include <iostream>
#define int long long
using namespace std;
const int N=1e3+10;
int a[N][N];
int n=1e2+10,ans;
signed main(){
    std::ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    int t;cin>>t;
    for(int i=1;i<=n;i++){
        a[i][1]=1;
        a[i][i]=1;
    }
    for(int i=3;i<=n;i++){
        for(int j=2;j<=i-1;j++){
            a[i][j]=a[i-1][j]+a[i-1][j-1];
        }
    }
    for(int i=1;i<=n;i++){
        for(int j=1;j<=i;j++){
            if(a[i][j]==t){
                cout<<++ans<<endl;
                return 0;
            }
            ans++;
        }
    }
    return 0;
}

I.双向排序（60%）

#include <iostream>
#include <algorithm>
//#define int long long
using namespace std;
const int N=1e5+10;
int a[N],n,m;
bool cmp(int l,int r){
    return l>r;
}
signed main(){
    std::ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    cin>>n>>m;
    for(int i=1;i<=n;i++){
        a[i]=i;
    }
    int sign,k;
    while(m--){
        cin>>sign>>k;
        if(sign==0){//从1到k降序
            sort(a+1,a+k+1,cmp);
        }
        else{//从k到n升序
            sort(a+k,a+n+1);
        }
    }
    for(int i=1;i<=n;i++){
        cout<<a[i]<<' ';
    }
    return 0;
}

J.括号序列（100%）

#include <iostream>
#include <string>
#include <cstring>
#include <cstdio>
#include <algorithm>
using namespace std;
#define int long long
const int N = 5e3 + 10, mod = 1e9 + 7; // 定义常量N和mod，mod用于计算结果的模数
int n; // 输入的字符串长度
string str; // 存储输入的括号序列
int f[N][N]; // 动态规划数组，f[i][j]表示前i个字符中有j个左括号待匹配时的方案数量
 
// calc函数用于计算结果
int calc() {
    memset(f, 0, sizeof(f)); // 初始化动态规划数组
    f[0][0] = 1; // 初始状态设为1，表示没有任何括号的情况只有一种可能
    for (int i = 1; i <= n; i++) { // 遍历输入的括号序列
        if (str[i] == '(') { // 如果当前字符是左括号
            for (int j = 1; j <= n; j++) { // 遍历所有可能的未匹配的左括号数量
                f[i][j] = f[i - 1][j - 1]; // 状态转移，因为遇到左括号，需要匹配的左括号数量减少1
            }
        }
        else { // 如果当前字符是右括号
            f[i][0] = (f[i - 1][0] + f[i - 1][1]) % mod; // 状态转移，如果之前没有未匹配的左括号，只能添加一个左括号，否则可以不添加或添加一个左括号
            for (int j = 1; j <= n; j++) { // 遍历所有可能的未匹配的左括号数量
                f[i][j] = (f[i - 1][j + 1] + f[i][j - 1]) % mod; // 状态转移，因为遇到右括号，需要匹配的左括号数量增加1，或者添加一个右括号来消除一个未匹配的左括号
            }
        }
    }
    for (int i = 0; i <= n; i++) { // 遍历所有可能的未匹配的左括号数量
        if (f[n][i]) { // 如果存在合法的方案
            return f[n][i]; // 返回方案数量
        }
    }
    return -1; // 如果没有合法的方案，返回-1
}
 
signed main() {
    cin >> str; // 输入括号序列
    n = str.size(); // 计算括号序列的长度
    str = " " + str; // 在字符串前添加一个空格，便于索引操作
    int l = calc(); // 调用calc函数计算结果
    reverse(str.begin() + 1, str.end()); // 反转括号序列
    for (int i = 1; i <= n; i++) { // 将括号序列中的左括号和右括号互换
        if (str[i] == '(') str[i] = ')';
        else str[i] = '(';
    }
    int r = calc(); // 再次调用calc函数计算结果
    printf("%lld\n", l * r % mod); // 输出结果，即两次计算结果的乘积对mod取模
    return 0;
}

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

Python 基于 OpenCV 视觉图像处理实战 之 背景知识

Python 基于 OpenCV 视觉图像处理实战 之 背景知识

Python 基于 OpenCV 视觉图像处理实战 之 背景知识 目录 Python 基于 OpenCV 视觉图像处理实战 之 背景知识 一、简单介绍 二、人工智能&#xff08;Artificial Intelligence&#xff0c;AI&#xff09; 三、OpenCV 四、计算机视觉任务的主要类型 五、计算机视觉是通…
阅读更多...
基于Python实现电商订单的数据分析

基于Python实现电商订单的数据分析

基于Python实现电商订单的数据分析 数据集&#xff1a;技术&#xff1a;功能&#xff1a;创新点&#xff1a;明确需求和目的&#xff1a; 数据集&#xff1a; 项目使用一家全球超市4年内的电商销售订单数据&#xff0c;数据集名为superstore_dataset2011-2015.csv。数据集共有…
阅读更多...
Tomcat详解

Tomcat详解

1Tomcat安装 下载 Tomcat&#xff1a;首先&#xff0c;您需要从 Tomcat 官方网站&#xff08;http://tomcat.apache.org&#xff09;下载适合您系统的最新版本的 Tomcat 软件包。通常情况下&#xff0c;您会选择一个稳定的版本进行下载。解压缩&#xff1a;下载完成后&#xf…
阅读更多...
Day34：安全开发-JavaEE应用反射机制攻击链类对象成员变量方法构造方法

Day34：安全开发-JavaEE应用反射机制攻击链类对象成员变量方法构造方法

目录 Java-反射-Class对象类获取 Java-反射-Field成员变量类获取 Java-反射-Method成员方法类获取 Java-反射-Constructor构造方法类获取 Java-反射-不安全命令执行&反序列化链构造 思维导图 Java知识点 功能&#xff1a;数据库操作&#xff0c;文件操作&#xff0c;…
阅读更多...
【三】安装k8s+kuboard, 拉取harbor镜像并执行yml文件

【三】安装k8s+kuboard, 拉取harbor镜像并执行yml文件

自己的配置 我在尊云上两百多买了三台2c4g的服务器&#xff0c;其实买两台就够了。 修改服务网卡掩码 确保几台服务器内网之间可以ping通 以尊云为例&#xff0c;vi /etc/sysconfig/network-scripts/ifcfg-eth1 修NETMASK值为255.0.0.0&#xff0c;重启服务器&#xff0c;尝试…
阅读更多...
鸿蒙Harmony应用开发—ArkTS声明式开发（基础手势：NavDestination）

鸿蒙Harmony应用开发—ArkTS声明式开发（基础手势：NavDestination）

作为子页面的根容器&#xff0c;用于显示Navigation的内容区。 说明&#xff1a; 该组件从API Version 9开始支持。后续版本如有新增内容&#xff0c;则采用上角标单独标记该内容的起始版本。 该组件从API Version 11开始默认支持安全区避让特性(默认值为&#xff1a;expandSaf…
阅读更多...
一文了解Cornerstone3D中窗宽窗位的3种设置场景及原理

一文了解Cornerstone3D中窗宽窗位的3种设置场景及原理

&#x1f506; 引言 在使用Cornerstone3D渲染影像时&#xff0c;有一个常用功能“设置窗宽窗位&#xff08;windowWidth&windowLevel&#xff09;”&#xff0c;通过精确调整窗宽窗位&#xff0c;医生能够更清晰地区分各种组织&#xff0c;如区别软组织、骨骼、脑组织等。…
阅读更多...
Unity中使用C#以【拟牛顿法】来求解非线性方程组

Unity中使用C#以【拟牛顿法】来求解非线性方程组

python科学计算包中有一个fsolve函数来求解非线性方程组&#xff0c;那么C#中用什么包和什么api与之对应呢&#xff1f;本文仅针对拟牛顿法求解过程展开MathNet包中对应API的考察和测试。 一、案例1 1、方程组 2、python的解法 &#xff08;1&#xff09;代码 from scipy.o…
阅读更多...
大语言模型智能体简介

大语言模型智能体简介

大语言模型&#xff08;LLM&#xff09;智能体&#xff0c;是一种利用大语言模型进行复杂任务执行的应用。这种智能体通过结合大语言模型与关键模块&#xff0c;如规划和记忆&#xff0c;来执行任务。构建这类智能体时&#xff0c;LLM充当着控制中心或“大脑”的角色&#xff0…
阅读更多...
【webrtc】m122：BitrateProber 源码阅读与分析

【webrtc】m122：BitrateProber 源码阅读与分析

pacing controller 需要 bitrate prober Pacing模块中存在一个BitrateProber prober_的成员变量，专门用来处理带宽探测 大神的分析也是基于最新版本webrtc的：ProbeController每次可能会生成多个探测源数据ProbeClusterConfig，其中每个源数据ProbeClusterConfig对应一个探测簇…
阅读更多...
现代DevOps如何改变软件开发格局

现代DevOps如何改变软件开发格局

在软件开发的早期&#xff0c;该过程通常是开发人员编写代码&#xff0c;再将其交给质量保证&#xff08;QA&#xff09;进行测试。这种瀑布开发方法可能会导致质量问题和延迟&#xff0c;因为问题是在周期后期发现的。 一、了解DevOps和测试左移 DevOps是Development和Opera…
阅读更多...
深度学习_VGG_3

深度学习_VGG_3

目标 知道VGG网络结构的特点能够利用VGG完成图像分类 2014年&#xff0c;牛津大学计算机视觉组&#xff08;Visual Geometry Group&#xff09;和Google DeepMind公司的研究员一起研发出了新的深度卷积神经网络&#xff1a;VGGNet&#xff0c;并取得了ILSVRC2014比赛分类项目…
阅读更多...
某聘 zp__stoken__

某聘 zp__stoken__

前言: 本文章中所有内容仅供学习交流使用&#xff0c;不用于其他任何目的&#xff0c;不提供完整代码&#xff0c;抓包内容、敏感网址、数据接口等均已做脱敏处理&#xff0c;严禁用于商业用途和非法用途&#xff0c;否则由此产生的一切后果均与作者无关&#xff01;wx a15018…
阅读更多...
Shell正则表达式

Shell正则表达式

目录 正则表达式的分类 基本组成部分 POSIX字符类 元字符 正则表达式的分类 基本的正则表达式&#xff08;Basic Regular Expression 又叫Basic RegEx 简称BREs&#xff09;扩展的正则表达式&#xff08;Extended Regular Expression 又叫Extended RegEx 简称EREs&#xf…
阅读更多...
鸿蒙Harmony应用开发—ArkTS声明式开发（基础手势：PatternLock）

鸿蒙Harmony应用开发—ArkTS声明式开发（基础手势：PatternLock）

图案密码锁组件&#xff0c;以九宫格图案的方式输入密码&#xff0c;用于密码验证场景。手指在PatternLock组件区域按下时开始进入输入状态&#xff0c;手指离开屏幕时结束输入状态完成密码输入。 说明&#xff1a; 该组件从API Version 9开始支持。后续版本如有新增内容&#…
阅读更多...
日期组件报错：Prop being mutated: “placement“

日期组件报错：Prop being mutated: “placement“

在使用vue2.0开发项目时遇到一个使用日期选择器的报错 报错截图&#xff1a; 对比官网比对没有发现问题&#xff0c;后来查询资料找到了两个解决方案 方案1&#xff08;推荐&#xff09;&#xff1a; 在日期组件的标签处添加如下属性placement“bottom-start”&#xff1a;…
阅读更多...
openssl3.2 - 官方demo学习 - encode - ec_encode.c

openssl3.2 - 官方demo学习 - encode - ec_encode.c

文章目录 openssl3.2 - 官方demo学习 - encode - ec_encode.c概述笔记产生ecc私钥产生ecc公钥测试工程备注备注END openssl3.2 - 官方demo学习 - encode - ec_encode.c 概述 官方demos/encode 目录中给了2个例子工程 功能是载入(RSA/ECC)公钥, 然后自己就可以拿内存中的公钥对…
阅读更多...
如何保护企业云上安全

如何保护企业云上安全

近日&#xff0c;CrowdStrike发布了《2024年全球威胁报告》&#xff0c;揭示了网络攻击的最新趋势。报告指出&#xff0c;网络攻击生态系统仍在持续增长&#xff0c;CrowdStrike在2023年观察到了34个新的威胁参与者。同时&#xff0c;攻击者正越来越多地瞄准云环境&#xff0c;…
阅读更多...
机器学习，剪刀，石头，布

机器学习，剪刀，石头，布

计算机视觉：剪刀，石头，步 TensorFlow AI人工智能及Machine Learning训练图集的下载建立分类模型并用图像进行训练检验模型总结当前AI Machine Learning 异常火爆，希望在MCU上使用机器学习，做图像识别的工作。看到一个剪刀，石头，步的学习程序，给大家分享一下。 TensorFl…
阅读更多...
Centos7 安装mongodb 7.0

Centos7 安装mongodb 7.0

官方手册参考&#xff1a; https://www.mongodb.com/docs/manual/tutorial/install-mongodb-on-red-hat/ Mongodb支持的版本 安装 MongoDB 社区版 按照以下步骤使用包管理器安装 MongoDB Community Edition yum。 配置包管理系统 ( yum) 创建一个/etc/yum.repos.d/mongodb-o…
阅读更多...
最新文章

Copyright @ 2022~2023