第十三届蓝桥杯c++b组国赛题解（还在持续更新中...）

news2024/11/23 23:47:24

第十三届蓝桥杯C++b组国赛真题pdf自取

 

试题A：2022

解题思路：

 有2022个物品，它们的编号分别是1到2022，它们的价值分别等于它们的编号。也就是说，有2022种物品，物品价值等于物品编号。

从2022个物品种选取10个物品，满足10个物品的价值之和为2022，用f[i][j][k]表示前i个物品里选择j个物品，价值之和为k的方案数 则对于前i种物品，有两种选择，选或者不选 f[i][j][k]=f[i-1][j][k] 不选 f[i][j][k]=f[i-1][j-1][k-i] 选 (为什么是k-i，因为第i个物品的体积就是i)

最后的答案是：379187662194355221

注意：本题记得开long long，不然真见祖宗了，hh

代码实现：

三维未优化空间（此代码只能在本地跑结果，直接交蓝桥杯官网测评会爆空间）

#include<iostream>
#include<algorithm>
using namespace std;
#define int long long
const int N=2500;
//dp[i][j][k]表示从前i件物品中选，每件物品的价值等于其编号，且当前选了j件物品，且当前价值为k的所有选法数 
int dp[N][15][N];
signed main(){
	//因为价值k为0，所以只有一种选法：就是啥也不选 
	for(int i=0;i<N;i++)dp[i][0][0]=1;
	for(int i=1;i<=2022;i++){
		for(int j=1;j<=10;j++){
			for(int k=1;k<=2022;k++){
				//不选第i个物品 
				dp[i][j][k]=dp[i-1][j][k];
				//选第i个物品 
				if(k>=i)dp[i][j][k]+=dp[i-1][j-1][k-i];
			}
		}
	}
	cout<<dp[2022][10][2022]<<endl;
	return 0;
}

二维优化空间：

#include<iostream>
#include<algorithm>
using namespace std;
#define int long long
const int N=2500;
int dp[15][N];
signed main(){
	dp[0][0]=1;
	for(int i=1;i<=2022;i++){
		for(int j=10;j>=1;j--){
			for(int k=i;k<=2022;k++){
				//不选第i个物品和不选第i个物品 
				dp[j][k]=dp[j][k]+dp[j-1][k-i];
			}
		}
	}
	cout<<dp[10][2022]<<endl;
	return 0;
}

试题B：钟表

解题思路：

for循环枚举时针（i）、分针（j）、秒针位置（k），计算三个针的角度

秒针的角度就是：s=360*k/60

分针的角度就是：m=360*j/60+s/60，因为秒针也会为分针贡献角度

时针的角度就是：h=360*i/12+m/12，因为分针也会为时针贡献角度

然后计算分针和时针的夹角A，分针的夹角B，为了让夹角A和夹角B能够处于同一个方向，A和B都取较小的半角

最后通过A-2B是否相等判断是否满足条件

注意：

1）double相减存在误差，最好不要直接判断相等

2）当 时、分、秒都为0时虽然也满足条件，但是题目要求找出的是一个0 时 0 分 0 秒以外的解，故时、分、秒同时为0的情况需要跳过

代码实现：

#include<bits/stdc++.h>
using namespace std;

int main()
{
for(int s=0;s<=6;++s){
for(int f=0;f<60;++f){
for(int m=0;m<60;++m){
if(s0&&f0&&m==0) continue;
double dm=360m/60;
double df=360f/60+dm/60;
double ds=360s/12+df/12;
double A=abs(df-ds),B=abs(df-dm);
//取小的角度
A=min(A,360-A);
B=min(B,360-B);
if(fabs(A-2B)<=1e-10){
printf(“%d %d %d\n”,s,f,m);
}
}
}
}
return 0;
}

试题C：卡片

解题思路：

二分枚举能够凑出的套牌数mid，通过check函数判断是否满足要求，如果满足要求，因为题目要求套牌数量最大化，故还得加大套牌数mid，继续判断是否满足条件，直到找不到比当前更大且满足条件的套牌数

check函数主要判断当前已有卡牌a[i]和当前可以手写的卡牌i的数量b[i]之和是否大于等于套牌数mid，如果小于，则一定不满足，否则统计当前总共需要的手写的卡牌数，最后判断总共手写的卡牌数是否小于等于题目中给的空白卡牌数，如果是则表示满足，否则表示不满足

代码实现：

#include<iostream>
#include<algorithm>
using namespace std;
#define int long long
const int N=2e5+5;
int a[N],b[N];
int n,m;
int check(int x){
    int temp=0;
    for(int i=0;i<n;i++){
    	//如果当前第i种卡牌已经满足条件，则第i种卡牌不需要消耗空白卡牌 
        if(x<=a[i])continue;
        //如果当前第i种卡牌就算用上所有能够手写第i种卡牌的空白卡牌仍然不满足条件，则直接返回false 
        if(x>a[i]+b[i])return 0;
        //否则统计当前用了多少张空白卡牌来手写第i种卡牌 
        temp+=x-a[i];
    }
    //如果使用的空白卡牌数超过了题目中提供的空白卡牌数m，则直接返回false 
    if(temp>m)return 0;
    //否则表示满足，返回true 
    else return 1;
}
signed main(){
    cin>>n>>m;
    for(int i=0;i<n;i++)cin>>a[i];
    for(int i=0;i<n;i++)cin>>b[i];
    int l=0,r=2e5+5;
    while(l<r){
        int mid=l+r+1>>1;
        //如果当前套牌数满足条件，继续加大套牌数 
        if(check(mid))l=mid;
        else r=mid-1;
    }
    cout<<l<<endl;
    return 0;
}

试题D：最大数字

解题思路：

dfs暴力搜索即可，因为要求数字进行上述操作后的数值最大可知，优先从左往右进行操作一定是最右的操作顺序

对于每个数位，如果当前数位能够通过减法操作变成9，那么肯定将当前数位变为9

否则肯定不用减法操作，因为在不满足上述条件基础上使用减法操作一定会使得数值减小。如果当前加法操作能够使得当前数值x变成[x+1,9]，则一定使用加法操作使其变成上述数值，但是不能超过上述数值，因为超过后会从0开始，数值就会减小

注意：

1）本题数值比较大，记得使用字符串存储和操作

2）每次递归记得恢复现场即可

代码实现：

#include<iostream>
#include<algorithm>
using namespace std;
string s,ans;
int a,b;
void dfs(int idx,int a,int b){
	//如果已经遍历完了整个数字的每一位，则更新最大值，并返回 
	if(idx>s.size()){
		ans=max(ans,s);
		return;
	}
	//当前数位通过减法操作变成9所需要的操作次数t 
	int t=s[idx]-'0'+1;
	//如果当前拥有的减法操作次数大于上述操作次数t，则将当前位变成9 
	if(b>=t){
		//保留现场 
		int temp=s[idx];
		//将当前位变成9
		s[idx]='9';
		//递归操作下一位，当前拥有的减法操作次数减少t次 
		dfs(idx+1,a,b-t);
		//恢复现场 
		s[idx]=temp;
	}
	//当前数位x通过加法操作变成[x+1,9]所需要的操作次数t1
	int t1=min(9-(s[idx]-'0'),a);
	如果当前拥有的加法操作次数大于上述操作次数t1，则使用加法操作修改当前位 
	if(a>=t1){
		//保留现场 
		int temp=s[idx];
		//修改当前位 
		s[idx]=s[idx]+t1;
		//递归操作下一位，当前拥有的加法操作次数减少t1次 
		dfs(idx+1,a-t1,b);
		//恢复现场 
		s[idx]=temp;
	}
}
int main(){
	cin>>s>>a>>b;
	dfs(0,a,b);
	cout<<ans<<endl; 
	return 0;
}

试题E：出差

解题思路：

最短路模板题，送分题，个人评价，不喜勿喷，hh

注意点：

1）需要建立双向边

2）建立从u到v的双向边时：

  1.建立从u到v的单向边，将当前道路的开销设置为城市 u 到城市 v 的时间加上在城市v隔离观察花费的时间即可

  2.建立从v到u的单向边，将当前道路的开销设置为城市 u 到城市 v 的时间加上在城市u隔离观察花费的时间即可

3）最后结果需要减去在城市n隔离观察的时间，因为是求到达城市n那一刻的开销

代码实现：

由于是模板题，就不写什么注释了，不懂的可以去看看dijksta算法的实现，希望谅解

#include<iostream>
#include<algorithm>
#include<queue>
#include<cstring>
using namespace std;
#define int long long
typedef pair<int,int>PII;
const int N=1e5+5,M=2*N;
int h[N],e[M],ne[M],w[M],a[N],dist[N],vis[N],idx;
void add(int x,int y,int z){
	e[idx]=y,w[idx]=z,ne[idx]=h[x],h[x]=idx++;
}
void dijkstra(){
	memset(dist,0x3f,sizeof dist);
	priority_queue<PII,vector<PII>,greater<PII> >q;
	q.push({0,1});
	dist[1]=0;
	while(q.size()){
		int dis=q.top().first;
		int s=q.top().second;
		q.pop();
		if(vis[s])continue;
		vis[s]=1;
		for(int i=h[s];~i;i=ne[i]){
			int j=e[i];
			if(dist[j]>dis+w[i]){
				dist[j]=dis+w[i];
				q.push({dist[j],j});
			}
		}
	}
}
signed main(){
	memset(h,-1,sizeof h);
	int n,m;
	cin>>n>>m;
	for(int i=1;i<=n;i++)cin>>a[i];
	while(m--){
		int x,y,z;
		cin>>x>>y>>z;
		add(x,y,z+a[y]);
		add(y,x,z+a[x]); 
	}
	dijkstra();
	cout<<dist[n]-a[n]<<endl;
	return 0;
}

试题F：费用报销

解题思路：

 dp[i]表示从第1天到第i天范围内的票据中选择的最大报销金额

从1枚举到一年的最大天数，每次考虑选择当前天的票据或者不选择当前天的票据

而选择当前天的票据的前提是上一次选择的票据一定在k天前且当前票据的报销金额加上k天前的最大报销金额不能超过m

则状态转移方程为：

dp[i]=max(dp[i]+dp[max(0,i-k)],dp[i-1])//如果第i天的票据能够满足条件，能选择
dp[i]=dp[i-1]//如果第i天的票据不满足条件，不能选择

代码实现：

#include<iostream>
#include<algorithm>
using namespace std;
const int N=5005;
//记录每月的天数 
int month[13]={0,31,28,31,30,31,30,31,31,30,31,30,31};
//dp[i]表示从第1天到第i天范围内的票据中选择的最大报销金额 
int dp[N];
int main(){
	int n,m,k;
	//前缀和求本年到当前月总共多少天 
	for(int i=1;i<=13;i++)month[i]+=month[i-1];
	cin>>n>>m>>k;
	while(n--){
		int x,y,z;
		cin>>x>>y>>z;
		//month[x-1]+y表示x月y号距离本年初共多少天 
		dp[month[x-1]+y]=max(dp[month[x-1]+y],z);
	}
	//从第一天枚举到本年最后一天 
	for(int i=1;i<=month[13];i++){
		//如果第i天的票据加上距离第i天前k天的票据的价值不超过m，则说明可以选择第i天的票据
		//取选择第i天的票据dp[i]+dp[max((int)0,i-k)]和不选择第i天的票据dp[i-1]的最大值 
		if(dp[i]+dp[max((int)0,i-k)]<=m)dp[i]=max(dp[i-1],dp[i]+dp[max((int)0,i-k)]);
		//如果第i天的票据不能选择，那么dp[i]直接就是dp[i-1]了 
		else dp[i]=dp[i-1];
	}
	cout<<dp[month[13]]<<endl; 
	return 0;
}

试题H：机房

解题思路：

（lca板子题）

首先要搞清楚题意，题意表达的意思就是对于一个点，它发送消息的延迟是与出度有关，也就是说某个点的出度是多少，那么消息经过它时就会延迟多久。

我们这里可以把1号点当做树根root，然后使用dist[x]表示x点发送消息到root所需要的时间。 很显然，x发送出去的时候经过自身的延迟后到达另外一个点，另外一个点在经过延迟到达下一个点，以此类推

那么任意两个点之间的距离一般就是使用dist[x] + dist[y] - 2 * dist[lca(a, b)] 但是对于本题而言，当减去两倍的最近公共祖先anc到root的距离时，就会把自身的一个延迟多减了一次，所以还需要加上anc的出度。 所以本题正确计算距离的公式应该为： d = (dist[x] + dist[y] - 2 * dist[anc] + d[anc]) 其中anc表示x和y的最近公共祖先，d[anc]表示点anc的出度

代码实现：

#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
#define int long long
const int N=1e5+5,M=2*N;
int h[N],e[M],ne[M],idx;
//fa[i][j]表示结点i向上跳2^j步所到达的结点
//depth[i]表示结点i的深度
//dist[i]表示结点i到根节点的数据传输时间
//d[i]表示和结点i相连的边数 
int fa[N][20],depth[N],dist[N],d[N];
void add(int x,int y){
	e[idx]=y,ne[idx]=h[x],h[x]=idx++;
}
void bfs(){
	queue<int>q;
	q.push(1);
	memset(depth,0x3f,sizeof depth);
	//结点0的深度为0，结点1的深度为1 
	depth[0]=0,depth[1]=1;
	//结点1（根结点）的传输时间为自己的延迟时间 
	dist[1]=d[1];
	while(q.size()){
		int t=q.front();
		q.pop();
		//遍历所有子节点 
		for(int i=h[t];~i;i=ne[i]){
			int j=e[i];
			//这句话其实表示子节点还未被访问过，因为访问过后,depth[j]一定小于depth[t]+1
			//如果未被访问过，则更新depth和dist数组 
			if(depth[j]>depth[t]+1){
				depth[j]=depth[t]+1;
				dist[j]=d[j]+dist[t];
				q.push(j);
				//利用倍增法依次更新往上跳的父节点 
				fa[j][0]=t;
				for(int k=1;k<=16;k++){
					//j向上跳2^k步等同于j先向上跳到2^(k-1)的位置，然后再往上跳2^(k-1)步 
					fa[j][k]=fa[fa[j][k-1]][k-1];
				}
			}
		}
	}
}
int lca(int a,int b){
	// 为方便处理,当a在b上面时,把a和b互换  
	if(depth[a]<depth[b])swap(a,b);
	//把深度更深的a往上跳到b
	for(int i=16;i>=0;i--){
		//当a跳完2^i依然在b下面,我们就一直跳
		if(depth[fa[a][i]]>=depth[b])a=fa[a][i];
	}
	//如果跳到了b 
	if(a==b)return a;
	//a,b同层但是不同结点 
	for(int i=16;i>=0;i--){
		//假如a,b都跳出根节点,fa[a][i]==fa[b][i]==0 不符合更新条件
		if(fa[a][i]!=fa[b][i]){
			a=fa[a][i];
			b=fa[b][i];
		}
	}
	//循环结束 到达lca下一层
    //lca(a,b) = 再往上跳1步即可
	return fa[a][0];
}
signed main(){
	int n,m;
	cin>>n>>m;
	memset(h,-1,sizeof h);
	for(int i=0;i<n-1;i++){
		int x,y;
		cin>>x>>y;
		//统计结点x和结点y的边（因为时间取决于每个结点的边数） 
		d[x]++,d[y]++;
		//建立双向边 
		add(x,y);
		add(y,x);
	}
	//初始化lca和dist数组 
	bfs();
	while(m--){
		int x,y;
		cin>>x>>y;
		//求最近公共祖先 
		int anc=lca(x,y);
		//直接套公式求解传输时间 
		cout<<dist[x]+dist[y]-2*dist[anc]+d[anc]<<endl;
	}
	return 0;
}

试题I：齿轮

解题思路：

这道题观察样例就可以知道，对于每个查询x，其实是问我们数组中是否两个数满足其倍数关系为x，所以我们只需要在数组输入的时候把每个数都标记一下，然后遍历一下整个数组，对于数组的每个数x，遍历一下它的倍数y，如果x*y被标记了，说明该数组能够找到两个数满足倍数为y的关系，那么就可以把y用另一个标记数组标记下来了，对于每个查询x，我们只需要看一下x是否被标记，只要被标记了，那么就输出YES，否则输出NO

注意：

1）当数组长度为1时，即最左边的齿轮就等同于最右边的齿轮，那么倍数1是满足条件的

2）当数组中存在相同的数字时，那么倍数1是满足条件的，否则倍数1肯定是不满足条件的

这道题我就不得不吐槽一下了，简直是极限卡常，用unordered_map直接卡掉40%的测试点，用数组才能过。所以写完这道题告诉我们不需要用unordered_map的时候最好还是不要用，否则会死得很难看,hh

代码实现：

#include<iostream>
#include<algorithm>
using namespace std;
const int N=2e5+5;
int mp[N],vis[N],a[N];
int main(){
    int n,m,flag=0;
    cin>>n>>m;
    for(int i=0;i<n;i++){
        cin>>a[i];
        //如果数组中遇到了相同的数，那么倍数1是满足条件的，标记一下 
        if(vis[a[i]])flag=1;
        //标记数组的每一个数，以便后续判断 
        vis[a[i]]=1;
    }
    //如果数组长度为1或者1被标记过了，则倍数1是满足条件的
    if(flag||n==1)mp[1]=1;
    //遍历数组的每个数a[i] 
    for(int i=0;i<n;i++){
    	//遍历数组每个数的倍数 
        for(int j=2;j*a[i]<=N;j++){
        	//如果a[i]*j被标记过， 那么倍数j是满足条件的，标记一下 
            if(vis[j*a[i]])mp[j]=1;
        }
    }
    while(m--){
        int x;
        cin>>x;
        //如果倍数x被标记过，直接输出YES 
        if(mp[x])cout<<"YES"<<endl;
        //否则输出NO 
        else cout<<"NO"<<endl;
    }
    return 0;
}

 

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

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

相关文章

虹科案例 | 虹科Dimetix激光测距传感器可实现无接触式监测采矿设备健康状况!

虹科案例 | 虹科Dimetix激光测距传感器可实现无接触式监测采矿设备健康状况!

Part.01 行业挑战 采矿业机器的环境条件通常非常恶劣&#xff0c;损坏的设备会导致生产力和利润下降。虹科虹科Dimetix激光测距传感器为采矿设备和危险区域机器的机器健康监测提供了非接触式解决方案。 采矿操作中的处理设备通常包括分离、混合和粉碎矿石的机械设备。许多重型…
阅读更多...
客户线上反馈：从信息搜集到疑难 bug 排查全流程经验分享

客户线上反馈：从信息搜集到疑难 bug 排查全流程经验分享

写在前面&#xff1a;本文是我在前端团队的第三次分享&#xff0c;应该很少会有开发者写客户反馈处理流程以及 bug 排查的心得技巧&#xff0c;全文比较长&#xff0c;写了一个多星期大概1W多字&#xff08;也是我曾经2年工作的总结&#xff09;&#xff0c;如果你有耐心阅读&a…
阅读更多...
因数据库字段可存储长度设置的小了，已达到设置字符类型的存储上限，导致数据存储时报错 及 常用的数据类型

因数据库字段可存储长度设置的小了，已达到设置字符类型的存储上限，导致数据存储时报错 及 常用的数据类型

项目场景&#xff1a; 提示&#xff1a;这里简述项目相关背景&#xff1a; 使用MySQL数据库&#xff0c;因数据库字段可存储长度设置的小了&#xff0c;已达到设置字符类型的存储上限&#xff0c;导致数据存储时报错 问题描述 提示&#xff1a;这里描述项目中遇到的问题&am…
阅读更多...
2天刷完这套八股文，offer到手啦？

2天刷完这套八股文，offer到手啦？

前言 大家好&#xff0c;最近有不少小伙伴在后台留言&#xff0c;得准备面试了&#xff0c;又不知道从何下手&#xff01;为了帮大家节约时间&#xff0c;特意准备了一份面试相关的资料&#xff0c;内容非常的全面&#xff0c;真的可以好好补一补&#xff0c;希望大家在都能拿…
阅读更多...
我的GIT练习Three

我的GIT练习Three

目录 前言 GIT安装教程 Git作者 GIT优点 GIT缺点 为什么要使用 Git GIT练习Three 总结 前言 Git 是一个分布式版本控制及源代码管理工具;Git 可以为你的项目保存若干快照&#xff0c;以此来对整个项目进行版本管理 GIT安装教程 点击进入查看教程&#xff1a;点击进入 G…
阅读更多...
(深入浅出）详解虚拟内存

(深入浅出）详解虚拟内存

概述 我们都知道一个进程是与其他进程共享CPU和内存资源的。正因如此&#xff0c;操作系统需要有一套完善的内存管理机制才能防止进程之间内存泄漏的问题。 为了更加有效地管理内存并减少出错&#xff0c;现代操作系统提供了一种对主存的抽象概念&#xff0c;即是虚拟内存&am…
阅读更多...
从未尝试过的 7 种处理 CSS 的方法

从未尝试过的 7 种处理 CSS 的方法

啊&#xff0c;Web 开发的世界——您可以从学习 HTML、JavaScript&#xff0c;当然还有 CSS 等基础知识开始。 但是一旦你在现实世界中构建应用程序&#xff0c;纯 CSS 就不再适用了。 挣扎是真的。 因此&#xff0c;今天我们将深入探讨使用 NextJS 为 React 应用程序编写 CSS…
阅读更多...
NLP与GPT联合碰撞：大模型与小模型联合发力

NLP与GPT联合碰撞：大模型与小模型联合发力

目录标题 NLP是什么东西&#xff1f;Al大小模型联合发力 NLP是自然语言处理&#xff0c;而GPT是自然语言生成模型。 它们的联合碰撞结果是大模型与小模型联合发力&#xff0c;是因为大模型可以提供更好的语言理解和生成能力&#xff0c;而小模型则可以更快地进行推理和预测。 …
阅读更多...
考虑微网新能源经济消纳的共享储能优化配置（Matlab代码实现）

考虑微网新能源经济消纳的共享储能优化配置（Matlab代码实现）

&#x1f4a5;&#x1f4a5;&#x1f49e;&#x1f49e;欢迎来到本博客❤️❤️&#x1f4a5;&#x1f4a5; &#x1f3c6;博主优势&#xff1a;&#x1f31e;&#x1f31e;&#x1f31e;博客内容尽量做到思维缜密&#xff0c;逻辑清晰&#xff0c;为了方便读者。 ⛳️座右铭&a…
阅读更多...
【剑指offer专项突破版】字符串篇——“C“

【剑指offer专项突破版】字符串篇——“C“

前言 剑指offer专项突破版&#xff08;力扣官网&#xff09;——> 点击进入 本文所属专栏——>点击进入 一.字符串中的变位词 题目分析 总结 要求——在字符串2中找到字符串的1的排列顺序之一 数据格式——仅包含小写字母——哈希表&#xff01; 返回值——bool值 思路分…
阅读更多...
国产数据库有哪些？关键行业数据库为何一定要国产化？

国产数据库有哪些？关键行业数据库为何一定要国产化？

国产数据库主要有以下几种&#xff1a; 1. 中国数据库&#xff08;ChinaDB&#xff09;&#xff1a;由中国科学院计算技术研究所开发的关系型数据库系统。 2. 华为GaussDB&#xff08;高斯数据库&#xff09;&#xff1a;国内首个软硬协同、全栈自主的国产数据库GaussDB&…
阅读更多...
操作系统-内存管理-内存管理

操作系统-内存管理-内存管理

目录 一、内存概念 1.1程序的链接 静态链接 装入时动态链接 运行时动态链接 1.2 程序的装入 绝对装入 可重定位装入(静态重定位) 动态运行时装入(动态重定位) 1.3内存空间的扩充 1.3.1覆盖 1.3.2交换技术 1.4连续管理分配管理方式 1.4.1单一连续分配 1.4.2固定分区分…
阅读更多...
设计师必备！Axure RP10汉化版下载，一站式工具满足所有需求！

设计师必备！Axure RP10汉化版下载，一站式工具满足所有需求！

Axure RP10 汉化版是一款全新的原型、设计、交付工具&#xff0c;它兼容 Axure、Figma、Sketch 和 Adobe XD 等格式&#xff0c;提供一站式协同设计&#xff0c;帮助团队高效工作。在本文中&#xff0c;我们将为你介绍 Axure RP10 汉化版即时设计的下载和安装步骤&#xff0c;让…
阅读更多...
c++学习——多态

c++学习——多态

多态 **多态的语法****多态的底层原理图****多态案1——计算机类****纯虚函数和抽象类****多态案例2——饮品****虚析构和纯虚析构****多态案例3—— 电脑组装** 多态是C面向对象三大特性之一 多态分为两类 静态多态:函数重载和运算符重载属于静态多态&#xff0c;复用函数名 动…
阅读更多...
ssm本地上传文件

ssm本地上传文件

SSM实现图片本地上传并保存到本地磁盘中 功能描述 实现房屋租赁网站中添加房屋信息的功能。其中add.jsp页面是一个表单提交信息——添加房屋 首先输入房屋的相关信息&#xff0c;并上传房屋的图片。上传成功后会将图片的名字添加到数据库中成功后跳转到success.jsp&#xff…
阅读更多...
华为OD机试 Java 实现【简单密码】【牛客练习题 HJ21】，附详细解题思路

华为OD机试 Java 实现【简单密码】【牛客练习题 HJ21】，附详细解题思路

一、题目描述 现在有一种密码变换算法。 九键手机键盘上的数字与字母的对应&#xff1a; 1--1&#xff0c; abc--2, def--3, ghi--4, jkl--5, mno--6, pqrs--7, tuv--8 wxyz--9, 0--0&#xff0c;把密码中出现的小写字母都变成九键键盘对应的数字&#xff0c;如&#xff1a;a …
阅读更多...
【PaperReading】科学可重复的基因组富集: CERNO 与其他八种算法的比较

【PaperReading】科学可重复的基因组富集: CERNO 与其他八种算法的比较

Gene set enrichment for reproducible science: comparison of CERNO and eight other algorithms 可重复性科学的基因组富集: CERNO 与其他八种算法的比较1. 引言2. 材料和方法2.1 CERNO算法2.2 进一步用于评估的算法2.3 数据集2.4 算法评估指标3. 结果3.1 CERNO算法的不同排…
阅读更多...
【前端 - HTML】第 2 课 - HTML 标签

【前端 - HTML】第 2 课 - HTML 标签

欢迎来到博主 Apeiron 的博客&#xff0c;祝您旅程愉快 &#xff01; 时止则止&#xff0c;时行则行。动静不失其时&#xff0c;其道光明。 目录 1、缘起 2、标题标签 3、段落标签 4、文本格式化标签 5、图像标签 5.1、基本作用 5.2、属性 6、超链接标签 7、音频标…
阅读更多...
STM32 FSMC机制

STM32 FSMC机制

引 言 STM32是ST(意法半导体)公司推出的基于ARM内核Cortex&#xff0d;M3的32位微控制器系列。Cortex&#xff0d;M3内核是为低功耗和价格敏感的应用而专门设计的&#xff0c;具有突出的能效比和处理速度。通过采用Thumb&#xff0d;2高密度指令集&#xff0c;Cortex&#xff0…
阅读更多...
五种I/O模型

五种I/O模型

一、I/O基本概念 I/O即数据的读取&#xff08;接收&#xff09;或写入&#xff08;发送&#xff09;操作 通常用户进程中的一个完整I/O分为两个阶段 (1)用户进程空间<-->内核空间 (2)内核空间<-->设备空间&#xff08;磁盘、网卡等&#xff09; I/O分为内存I/O、…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023