1. Toy模板网首页
  2. > Toy博客

十三届蓝桥杯JAVA B组国赛部分题解

10月前 作者：I_am_a_String 分类：Toy博客 阅读(49) 违法举报

这篇具有很好参考价值的文章主要介绍了十三届蓝桥杯JAVA B组国赛部分题解。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。


大学总共参加了三届蓝桥杯，这应该是我最后一次参加蓝桥杯了，再写一篇题解算是给自己的业余竞赛结个尾。我的题解肯定不是最好的，甚至有许多错误，能给大家提供下思路就行。

A 重合次数

十三届蓝桥杯JAVA B组国赛部分题解
思路：模拟下时钟就行，签到题
答案：502-8=494(由于匀速运动，59分59秒到0分0秒实际算一次)


public class Main {

	public static void main(String[] args) {
		int h = 6;
		int m = 13;
		int s = 22;
		long result = 0;
		while(true) {
			s++;
			if(s==60) {
				s=0;
				m++;
			}
			if(m==60) {
				m=0;
				h++;
			}
			if(s==m)result++;
			if(h==14&&m==36&&s==20)break;
		}
		System.out.println(result);

	}

}

B 数数

十三届蓝桥杯JAVA B组国赛部分题解
思路：最大的质因子不大于23333333/（2^11）=11393，筛出11393前的质数，把范围的数挨个检测就是，10的7次方*10的三次方的数量级，10的九次方数量级大概是1s，这题直接暴力大概100s就能跑出来（实际上我比赛时大概也就跑了一两分钟，读完C题题目准备写时发现已经跑出来了），所以直接暴力就行。
答案：25606


public class Main {

	public static void main(String[] args) {
		//欧拉筛
		int N = 11393;
		int m =	2333333;
		int[] p = new int[N+1];
		int[] f = new int[N+1];
		int cnt=0;
		for(int i=2;i<=N;i++) {
			if(f[i]==0)p[cnt++]=i;
			for(int j=0;j<cnt&&p[j]*i<=N;j++) {
				f[p[j]*i]=1;
				if(i%p[j]==0)break;
			}
		}
		
		//挨个检测
		int result = 0;
		for(int i=2333333;i<=23333333;i++) {
			int tmp = 0;
			int now = i;
			while(tmp<12) {
				int flag=0;//判断是否能整除
				for(int j=0;j<cnt;j++) {
					if(now%p[j]==0) {
						tmp++;
						now/=p[j];
						flag=1;
						break;
					}
				}
				if(flag==0)break;
			}
			if(now==1&&tmp==12)result++;//能整除且刚好12个质因子
		}
		System.out.println(result);
	}

}

C 左移右移

十三届蓝桥杯JAVA B组国赛部分题解
思路：乍一看第一反应是双头队列，然而发现移动的x并非下标而是具体的数，每次移动都去找那个数肯定是不高效，不过200000*200000貌似直接这样暴力也能ac，这里提供一种更快的思路，给每个数一个cnt，维护zuo和you两个变量，每次左移将- - zuo赋给cnt，右移++you赋给cnt，然后根据cnt排序挨个输出就行，nlogn的复杂度，这样应该是最优解了。再就是10w的输入输出，直接scanner和sysout估计会卡输入输出。


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Comparator;

public class Main {

	public static void main(String[] args) throws IOException {
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		PrintWriter out = new PrintWriter(System.out);
		String line = in.readLine();
		String[] ml = line.split(" ");
		int N = Integer.parseInt(ml[0]);
		int M = Integer.parseInt(ml[1]);
		num[] allnum = new num[N+1];
		allnum[0]=new num(0,9999999);
		for(int i=1;i<=N;i++) {
			allnum[i]=new num(i, i);
		}
		long zuo = 1;
		long you = N;
		for(int i=0;i<M;i++) {
			line = in.readLine();
			ml = line.split(" ");
			char zy = ml[0].charAt(0);
			int x = Integer.parseInt(ml[1]);
			if(zy=='L') allnum[x].cnt=--zuo;
			else allnum[x].cnt=++you;
			
		}
		Arrays.sort(allnum,new Comparator<num>() {
			@Override
			public int compare(num arg0, num arg1) {
				if(arg0.cnt>arg1.cnt) return 1;
				else return -1;
			}
		});
		out.print(allnum[0].id);
		for(int i=1;i<N;i++)out.print(" "+allnum[i].id);
		out.flush();
	}

}

class num {
	long id;
	long cnt;
	public num(long id,long cnt) {
		this.id=id;
		this.cnt=cnt;
	}
}

D 窗口

十三届蓝桥杯JAVA B组国赛部分题解
十三届蓝桥杯JAVA B组国赛部分题解
十三届蓝桥杯JAVA B组国赛部分题解
十三届蓝桥杯JAVA B组国赛部分题解
思路：直接模拟，借用上题思路，用id记录优先级，每次操作将其id赋值当前最大，最后根据id排序,从下往上依次涂显示器。


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Comparator;

public class D {

	static char[][] map;
	static int N;
	static int M;
	static int nowID=1;
	static ck[] allCK;
	public static void main(String[] args) throws IOException  {
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		String line = in.readLine();
		String[] ml = line.split(" ");
		N = Integer.parseInt(ml[0]);
		M = Integer.parseInt(ml[1]);
		map = new char[N][M];
		for(int i=0;i<N;i++) {
			for(int j=0;j<M;j++) {
				map[i][j]='.';
			}
		}
		
		allCK = new ck[100001];
		for(int i=0;i<=100000;i++)allCK[i]= new ck(i, 0, 0, 0, 0, -1);
		
		line = in.readLine();
		int K = Integer.parseInt(line);
		
		for(int i=0;i<K;i++) {
			line = in.readLine();
			ml = line.split(" ");
			if(ml[0].equals("new")) newCK(Integer.parseInt(ml[1]),Integer.parseInt(ml[2]),Integer.parseInt(ml[3]),Integer.parseInt(ml[4]),Integer.parseInt(ml[5]));
			else if(ml[0].equals("move")) moveCK(Integer.parseInt(ml[1]),Integer.parseInt(ml[2]),Integer.parseInt(ml[3]));
			else if(ml[0].equals("resize")) resizeCK(Integer.parseInt(ml[1]),Integer.parseInt(ml[2]),Integer.parseInt(ml[3]));
			else if(ml[0].equals("close")) closeCK(Integer.parseInt(ml[1]));
			else  activeCK(Integer.parseInt(ml[1]));
		}
		
		Arrays.sort(allCK,new Comparator<ck>() {
			@Override
			public int compare(ck o1, ck o2) {
				if(o1.id>o2.id) return 1;
				return -1;
			}
		});
		
		int now = 0;
		while(allCK[now].id<0)now++;
		
		for(;now<=100000;now++) {
			ck tmp = allCK[now];
			
			for(int i=tmp.top;i<=tmp.top+tmp.height-1;i++) {
				for(int j=tmp.left;j<=tmp.left+tmp.width-1;j++) {
					if(i>=0&&i<N&&j>=0&&j<M)map[i][j]=' ';
				}
			}
			
			
			if(tmp.top>=0&&tmp.top<N)
				for(int i=tmp.left;i<=tmp.left+tmp.width-1;i++) {
					if(i>=0&&i<M)map[tmp.top][i]='-';
				}
			if((tmp.top+tmp.height-1)>=0&&(tmp.top+tmp.height-1)<N)
				for(int i=tmp.left;i<=tmp.left+tmp.width-1;i++) {
					if(i>=0&&i<M)map[tmp.top+tmp.height-1][i]='-';
				}
			if(tmp.left>=0&&tmp.left<M)
				for(int i=tmp.top;i<=tmp.top+tmp.height-1;i++) {
					if(i>=0&&i<N)map[i][tmp.left]='|';
				}
			if((tmp.left+tmp.width-1)>=0&&(tmp.left+tmp.width-1)<M)
				for(int i=tmp.top;i<=tmp.top+tmp.height-1;i++) {
					if(i>=0&&i<N)map[i][(tmp.left+tmp.width-1)]='|';
				}
			
			if(tmp.left>=0&&tmp.left<M&&tmp.top>=0&&tmp.top<N) map[tmp.top][tmp.left]='+';
			if((tmp.left+tmp.width-1)>=0&&(tmp.left+tmp.width-1)<M&&tmp.top>=0&&tmp.top<N) map[tmp.top][(tmp.left+tmp.width-1)]='+';
			if(tmp.left>=0&&tmp.left<M&&(tmp.top+tmp.height-1)>=0&&(tmp.top+tmp.height-1)<N) map[(tmp.top+tmp.height-1)][tmp.left]='+';
			if((tmp.left+tmp.width-1)>=0&&(tmp.left+tmp.width-1)<M&&(tmp.top+tmp.height-1)>=0&&(tmp.top+tmp.height-1)<N) map[(tmp.top+tmp.height-1)][(tmp.left+tmp.width-1)]='+';
		}
		
		for(int i=0;i<N;i++) {
			for(int j=0;j<M;j++) {
				System.out.print(map[i][j]);
			}
			System.out.println();
		}
	}
	private static void activeCK(int tpid) {
		allCK[tpid].id=nowID++;	
	}
	private static void closeCK(int tpid) {
		allCK[tpid].id=-1;
	}
	private static void resizeCK(int tpid, int theight, int twidth) {
		allCK[tpid].id=nowID++;
		allCK[tpid].height=theight;
		allCK[tpid].width=twidth;	
	}
	private static void moveCK(int tpid, int tvertical, int thorizontal) {
		allCK[tpid].id=nowID++;
		allCK[tpid].top=allCK[tpid].top+tvertical;
		allCK[tpid].left=allCK[tpid].left+thorizontal;
		
	}
	private static void newCK(int tpid, int ttop, int tlefg, int theight, int twidth) {
		allCK[tpid].id=nowID++;
		allCK[tpid].top=ttop;
		allCK[tpid].left=tlefg;
		allCK[tpid].height=theight;
		allCK[tpid].width=twidth;
	}
	

}

class ck{
	int pid;
	int top;
	int left;
	int height;
	int width;
	int id;
	public ck(int pid,int top,int left,int height,int width,int id) {
		this.pid=pid;
		this.top=top;
		this.left=left;
		this.height=height;
		this.width=width;
		this.id=id;
	}
}

E 迷宫

十三届蓝桥杯JAVA B组国赛部分题解
十三届蓝桥杯JAVA B组国赛部分题解
思路：很基础的搜索题，就是搜索时加了个传送门的分支，当时只看到了20*20，直接dfs了，写题解才发现ac要2000x2000，dfs肯定爆栈了，得改写成bfs，这里仅贴dfs代码，bfs写法为从终点往各个点走，亦可以打表或者dp。




import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;

public class E {
	static int[][] rem;
	static int N;
	static int[][] map;
	static csm[][] allcsm;
	static int[][] dir = {{1,0},{-1,0},{0,1},{0,-1}};
	static int min=99999999;
	public static void main(String[] args) throws IOException  {
		Scanner in = new Scanner(System.in);
		N = in.nextInt();
		int M = in.nextInt();
		rem = new int[N+1][N+1];
		map = new int[N+1][N+1];
		allcsm = new csm[N+1][N+1];
		for(int i=0;i<M;i++) {
			int x1=in.nextInt();
			int y1=in.nextInt();
			int x2=in.nextInt();
			int y2=in.nextInt();
			map[x1][y1]=1;
			map[x2][y2]=1;
			allcsm[x1][y1]=new csm(x2, y2);
			allcsm[x2][y2]=new csm(x1, y1);
		}
		double sum = 0;
		for(int i=1;i<=N;i++) {
			for(int j=1;j<=N;j++) {
				min = 99999999;
				rem[i][j]=1;
				dfs(i,j,0);
				rem[i][j]=0;
				sum+=min;
			}
		}
		System.out.printf("%.02f\n",sum/(N*N));
	}
	private static void dfs(int x, int y, int n) {
		if(x==N&&y==N) {
			if(n<min)min=n;
			return;
		}
		if(map[x][y]==1) {
			int nx=allcsm[x][y].x;
			int ny=allcsm[x][y].y;
			if(rem[nx][ny]==0) {
				rem[nx][ny]=1;
				dfs(nx, ny, n+1);
				rem[nx][ny]=0;
			}
		}
		for(int d=0;d<4;d++) {
			int nx = x+dir[d][0];
			int ny = y+dir[d][1];
			if(nx>=1&&nx<=N&&ny>=1&&ny<=N&&rem[nx][ny]==0) {
				rem[nx][ny]=1;
				dfs(nx, ny, n+1);
				rem[nx][ny]=0;
			}
		}
		
	}

	

}

class csm{
	int x;
	int y;
	public csm (int x,int y) {
		this.x=x;
		this.y=y;
	}
}

F 小球称重

十三届蓝桥杯JAVA B组国赛部分题解
十三届蓝桥杯JAVA B组国赛部分题解
思路：所有球标为0记为未测试。
大于和小于号：小的一边标记不为1（已排除嫌疑）的标为-1记为嫌疑人，
大的一边标为1记为排除嫌疑。
等于号：两边都记为1排除嫌疑
最后统计-1和0的数量，若标记为-1的球的数量不为0就是答案，否则标记为0的球的数量是答案。
这里数据量大时用数组记录会爆内存，当另寻它法。


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.StreamTokenizer;
import java.util.ArrayList;
import java.util.Scanner;

public class Main {
	public static void main(String[] args) throws IOException  {
		Scanner in = new Scanner(System.in);
		int N = in.nextInt();
		int M = in.nextInt();
		int[] rem = new int[N+1];
		for(int i=0;i<M;i++) {
			int K = in.nextInt();
			ArrayList<Integer> l = new ArrayList<>(); 
			ArrayList<Integer> r = new ArrayList<>(); 
			for(int j=0;j<K;j++) {
				int x = in.nextInt();
				l.add(x);
			}
			for(int j=0;j<K;j++) {
				int x = in.nextInt();
				r.add(x);
			}
			
			String tmp = in.next();
			if(tmp.equals(">")) {
				for(int j=0;j<K;j++) {
					rem[l.get(j)]=1;
				}
				for(int j=0;j<K;j++) {
					if(rem[r.get(j)]==0){
						rem[r.get(j)]=-1;
					}
				}
			}else if(tmp.equals("<")) {
				for(int j=0;j<K;j++) {
					rem[r.get(j)]=1;
				}
				for(int j=0;j<K;j++) {
					if(rem[l.get(j)]==0){
						rem[l.get(j)]=-1;
					}
				}
			}else {
				for(int j=0;j<K;j++) {
					rem[l.get(j)]=1;
				}
				for(int j=0;j<K;j++) {
					rem[r.get(j)]=1;
				}
			}
		}
		
		int cnt = 0;
		int r = 0;
		for(int i=1;i<N;i++) {
			if(rem[i]==-1) cnt++;
			if(rem[i]==0) r++;
		}
		
		if(cnt!=0)System.out.println(cnt);
		else System.out.println(r);
	}
	

}

G 背包与魔法

十三届蓝桥杯JAVA B组国赛部分题解
十三届蓝桥杯JAVA B组国赛部分题解思路：很基础的01背包，就是转移方法多了个要不要用魔法的分支。
这里题意有歧义，如果理解成只能用从头到尾一次魔法，这里当用2维dp，k为0时表示没用魔法，k为1时表示用了。dp[j][0]取dp[j][0]和dp[j-w[i]][0]+v[i]中较大者，分别表示不用魔法装i和不装i，dp[j][1]取dp[j][1]，dp[j-w[i]][1]和dp[j-w[i]-wk][0]中最大着，分别表示不装i已用魔法，装i已用魔法，未用魔法当前物品i用魔法并装。



import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.StreamTokenizer;


public class G {
	public static void main(String[] args) throws IOException  {
		StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
		in.nextToken();
		int N = (int)in.nval;
		in.nextToken();
		int M = (int)in.nval;
		in.nextToken();
		int wK = (int)in.nval;
		int[] W = new int[N+1];
		int[] V = new int[N+1];
		int[] dp = new int[M+2];
		for(int i=1;i<=N;i++) {
			in.nextToken();
			int wi = (int)in.nval;
			in.nextToken();
			int vi = (int)in.nval;
			W[i]=wi;
			V[i]=vi;
		}
		for(int i=1;i<=N;i++) {
			for(int j=W[i];j<=M;j++) {
				int max=0;
				max=Math.max(dp[j],dp[j-W[i]]+V[i]);
				if(j>=W[i]+wK)max=Math.max(max, dp[j-wK-W[i]]+V[i]*2);
				dp[j]=max;
			}
		}
		System.out.println(dp[M]);
	}
	

}

H 修路

十三届蓝桥杯JAVA B组国赛部分题解
十三届蓝桥杯JAVA B组国赛部分题解
十三届蓝桥杯JAVA B组国赛部分题解
思路：和20年国赛画廊没啥区别

https://blog.csdn.net/I_am_a_String/article/details/117568160

I 围栏

十三届蓝桥杯JAVA B组国赛部分题解
十三届蓝桥杯JAVA B组国赛部分题解
不会

十三届蓝桥杯JAVA B组国赛部分题解
思路1：暴力枚举，用kmp或者其它匹配方法判断是否包含子串。
思路2: 直接找符合范围长度的数，把左右边界字符串长度-4，就是你要找到数字串长度范围，求个全排列把2022往中间插入，判断是否在范围内就行，2022后面加0的情况单独分析。
eg： 左边界100000 右边界20000000
左：6-4=2，右：8-4=4
全排列10到9999
如12344把2022往里面插就是2022 12344，1 2022 2344，12 2022 2344 …
判断是否在100000和20000000之间就行。
最后单独考虑202200，2022000，20200000文章来源地址https://www.toymoban.com/news/detail-478732.html


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.StreamTokenizer;
import java.util.ArrayList;
import java.util.Scanner;

public class F {
	public static void main(String[] args) throws IOException  {
		Scanner in = new Scanner(System.in);
		int N = in.nextInt();
		int M = in.nextInt();
		int[] rem = new int[N+1];
		for(int i=0;i<M;i++) {
			int K = in.nextInt();
			ArrayList<Integer> l = new ArrayList<>(); 
			ArrayList<Integer> r = new ArrayList<>(); 
			for(int j=0;j<K;j++) {
				int x = in.nextInt();
				l.add(x);
			}
			for(int j=0;j<K;j++) {
				int x = in.nextInt();
				r.add(x);
			}
			
			String tmp = in.next();
			if(tmp.equals(">")) {
				for(int j=0;j<K;j++) {
					rem[l.get(j)]=1;
				}
				for(int j=0;j<K;j++) {
					if(rem[r.get(j)]==0){
						rem[r.get(j)]=-1;
					}
				}
			}else if(tmp.equals("<")) {
				for(int j=0;j<K;j++) {
					rem[r.get(j)]=1;
				}
				for(int j=0;j<K;j++) {
					if(rem[l.get(j)]==0){
						rem[l.get(j)]=-1;
					}
				}
			}else {
				for(int j=0;j<K;j++) {
					rem[l.get(j)]=1;
				}
				for(int j=0;j<K;j++) {
					rem[r.get(j)]=1;
				}
			}
		}
		
		int cnt = 0;
		int r = 0;
		for(int i=1;i<N;i++) {
			if(rem[i]==-1) cnt++;
			if(rem[i]==0) r++;
		}
		
		if(cnt!=0)System.out.println(cnt);
		else System.out.println(r);
	}
	

}

到了这里，关于十三届蓝桥杯JAVA B组国赛部分题解的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 第十三届蓝桥杯国赛 Web 前端组（大学组） 真题练习及答案解析

    考点：数组方法 思路：利用splice()方法 考点：flex布局 思路：照着写就行 考点： DOM 操作 思路：1 先做需求：隐藏开始按钮，方格上的图片显示后又隐藏。 2 再做第一次点击图片翻转效果。 3 做第二次点击的逻辑判断，若水果相同则，进行消除，加分操作，水果不同，进行隐

    2024年02月06日
    浏览(62)

  • 第十三届蓝桥杯 C/C++ 大学B组 题解

    进制计算简单模拟 遍历2022的每一天，转成字符串拼接，然后判断 找规律 主要就是看懂题意和取模的问题。 321 对应八进制、十进制、二进制 计算过程为： 3 ∗ 10 ∗ 2 + 2 ∗ 2 + 1 = 65 3*10*2+2*2+1 = 65 3 ∗ 10 ∗ 2 + 2 ∗ 2 + 1 = 65 通过枚举上下边界，和前缀和，就转成了一维数组求子

    2023年04月11日
    浏览(45)

  • 第十三届蓝桥杯省赛与国赛真题题解大汇总（十四届参赛者必备）

      大家好，我是执梗。本文汇总了我写的第十三届蓝桥杯所有省赛真题与国赛真题，会针对每道题打出我自己的难度评星⭐️，也会给出每道题的算法标签，帮助大家更有针对性的去学习和准备，当然许多题目由于难度或时间的原因暂未更新，如果有不懂的问题也可以在评

    2024年02月11日
    浏览(77)
  • 看看去年蓝桥考了什么，第十三届蓝桥杯省赛（C/C++ 大学B组）题解

    看看去年蓝桥考了什么，第十三届蓝桥杯省赛（C/C++ 大学B组）题解

    本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。 九进制正整数 (2022)9 转换成十进制等于多少？ 最大运行时间：1s 最大运行内存: 512M 这是一道经典的进制转换题目，具体可以点进链接看看这篇文章。进制转换点击这里！！！ 本题为填空题，只

    2024年02月02日
    浏览(53)
  • 2022蓝桥杯C++B组国赛真题题解

    2022蓝桥杯C++B组国赛真题题解

    目录 A:2022 B:钟表 C:卡牌 D:最大数字 E：出差 F：费用报销 G:故障 H：机房 I:齿轮 J:搬砖 问题描述 将 2022 拆分成 10 个互不相同的正整数之和, 总共有多少种拆分方法? 注意交换顺序视为同一种方法, 例如 2022=1000+1022 和 1022+1000 就视为同一种方法。 答案提交 这是一道结果填空的

    2024年02月06日
    浏览(43)
  • 2022 第十三届蓝桥杯大赛软件赛省赛（第二场），C/C++ 大学B组题解

    2022 第十三届蓝桥杯大赛软件赛省赛（第二场），C/C++ 大学B组题解

    2022 第十三届蓝桥杯大赛软件赛省赛（第二场），C/C++ 大学B组题解 补题链接：地址 第1题 —— 练习 （5分） 题意：过了样例交上去0分，问可能是ABC的哪一种 显然都是，答案：ABC 第2题 —— 三角回文数 （5分） 题意：求第一个大于某2e8的数的回文数，且满足他可以等于1+2+…

    2023年04月09日
    浏览(56)
  • 十三届蓝桥杯国赛2022

    十三届蓝桥杯国赛2022

    分苹果，不同之处在于一个盘子可以放0个苹果 直接贪心思想 过了90%，这种贪心其实无法保证全局最优 哪个局部没有最优呢？ if(x=by=a) 这里，是选则用 A 还是用 B 我的选取规则是 尽量保留 AB 的总次数尤其是 A ，我想的是在 AB 都无法到达 9 的时候，只能用上A。但是，B也很珍

    2024年02月07日
    浏览(51)
  • 第十三届蓝桥杯C++B组j国赛

    第十三届蓝桥杯C++B组j国赛

    题目 2693: 这天，小明在整理他的卡牌。 他一共有 n 种卡牌，第 i 种卡牌上印有正整数数 i(i ∈ [1, n])，且第 i 种卡牌 现有 ai 张。 而如果有 n 张卡牌，其中每种卡牌各一张，那么这 n 张卡牌可以被称为一 套牌。小明为了凑出尽可能多套牌，拿出了 m 张空白牌，他可以在上面写

    2024年02月08日
    浏览(48)
  • 蓝桥杯第十三届单片机国赛程序

    蓝桥杯第十三届单片机国赛程序

    写在前面： 做完总体来说感觉一年比一年难了（估计是被骂的），虽然十三届用的底层少，但是做起来困难重重。 最难的难点在于定时器安排问题。15F2K60S2系列单片机只有三个定时器，本届题目考到了频率测量、超声波、PWM输出，再加上刷新，每一个都需要一个定时器，比

    2024年02月08日
    浏览(52)
  • 蓝桥杯单片机第十三届国赛客观题（深夜学习——单片机）

    蓝桥杯单片机第十三届国赛客观题（深夜学习——单片机）

    1.填空题 （2）不同的地址范围： data：0x00-0xff idata：0x0000-0xffff xdata：0x0000-0xffff pdata：0x00-0xff code：0x0000-0xffff 2.选择题 （3）模电——》多级放大电路 （6）DS18B20 (7)模电——》二极管  （8）单片机      

    2024年02月11日
    浏览(67)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包