蓝桥杯第一次校内模拟赛java题解

说明一下,一下代码不是官方题解,仅仅只是个人的题解,不一定完全正确,如果有错误,希望大家在评论区指出来。
(1)

问题描述
  在计算机存储中,15.125GB是多少MB?
答案提交
  这是一道结果填空的题,你只需要算出结果后提交即可。本题的结果为一个整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。

签到题:1024*15.125=15488

(2)

问题描述
  1200000有多少个约数(只计算正约数)。
答案提交
  这是一道结果填空的题,你只需要算出结果后提交即可。本题的结果为一个整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。

约数就是能被1200000整除的数,for循环遍历找一下即可 ,答案96

public class Main {
	public static void main(String[] args) {
		int sum=0,n=1200000;
		for(int i=1;i<=1200000;i++) {
			if(n%i==0) {
				sum++;
			}
		}
		System.out.println(sum);
	}
}

(3)

问题描述
  一棵包含有2019个结点的树,最多包含多少个叶结点?
答案提交
  这是一道结果填空的题,你只需要算出结果后提交即可。本题的结果为一个整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。

没说是二叉树,所以一个根和2018个叶结点

(4)

问题描述
  在12019中,有多少个数的数位中包含数字9?
  注意,有的数中的数位中包含多个9,这个数只算一次。例如,1999这个数包含数字9,在计算只是算一个数。
答案提交
  这是一道结果填空的题,你只需要算出结果后提交即可。本题的结果为一个整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。

还是for循环对1到2019之间每一个数判断即可,答案544

public class Main {
	public static void main(String[] args) {
		int sum=0;
		for(int i=1;i<=2019;i++){
			int ii=i;
			while(ii>0) {
				if(ii%10==9) {
					sum++;
					break;
				}
				ii/=10;
			}
		}
		System.out.println(sum);
	}
}

(5)

问题描述
  一个正整数如果任何一个数位不大于右边相邻的数位,则称为一个数位递增的数,例如1135是一个数位递增的数,而1024不是一个数位递增的数。
  给定正整数 n,请问在整数 1 至 n 中有多少个数位递增的数?
输入格式
  输入的第一行包含一个整数 n。
输出格式
  输出一行包含一个整数,表示答案。
样例输入
30
样例输出
26
评测用例规模与约定
  对于 40% 的评测用例,1 <= n <= 1000。
  对于 80% 的评测用例,1 <= n <= 100000。
  对于所有评测用例,1 <= n <= 1000000

用暴力对每一个数进行判断不知道能不能过所以测评,但用数位dp一定能过,可以网上查下数位dp的模板

import java.util.Arrays;
import java.util.Scanner;

//数位dp
public class Main {
	static int[] a=new int[11];
	static int[][] dp=new int[11][10];
	public static void main(String[] args) {
		 Scanner sc=new Scanner(System.in);
		 int n=sc.nextInt();
		 for(int i=0;i<dp.length;i++) {
			 Arrays.fill(dp[i], -1);
		 }
			 System.out.println(solve(n)-1);		
	}
	public static int dfs(int pos, int pre, boolean limit)
	{
	    if(pos == -1)
	        return 1;
	    if(!limit && dp[pos][pre] != -1) return dp[pos][pre];
	    int up = limit?a[pos]:9;
	    int ans = 0;
	    for(int i=pre; i<=up; ++i)
	        ans += dfs(pos-1, i, limit&&i==a[pos]);
	    if(!limit)
	        dp[pos][pre] = ans;
	    return ans;
	}
	 
	public static int solve(int num)
	{
	    int k = 0;
	    while(num>0)
	    {
	        a[k++] = num%10;
	        num /= 10;
	    }
	    return dfs(k-1, 0, true);
	}
}

(6)

问题描述
  小明对类似于 hello 这种单词非常感兴趣,这种单词可以正好分为四段,第一段由一个或多个辅音字母组成,第二段由一个或多个元音字母组成,第三段由一个或多个辅音字母组成,第四段由一个或多个元音字母组成。
  给定一个单词,请判断这个单词是否也是这种单词,如果是请输出yes,否则请输出no。
  元音字母包括 a, e, i, o, u,共五个,其他均为辅音字母。
输入格式
  输入一行,包含一个单词,单词中只包含小写英文字母。
输出格式
  输出答案,或者为yes,或者为no。
样例输入
lanqiao
样例输出
yes
样例输入
world
样例输出
no
评测用例规模与约定
  对于所有评测用例,单词中的字母个数不超过100

简单模拟题,首字母一定是辅音字母,然后用开关变量控制后面的是元音还是辅音,再用一个变量记录下变化的次数,如果变化了3次就是对的


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

public class Main {
	public static void main(String[] args) throws IOException {
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		String s=br.readLine();
		boolean flag=false;
		int sum=0;
		//如果第一个字母是元音,直接退出
		if(s.charAt(0)=='a'||s.charAt(0)=='e'||s.charAt(0)=='i'||s.charAt(0)=='o'||s.charAt(0)=='u') {
			System.out.println("no");
			return;
		}
		for(int i=0;i<s.length();i++) {
			//如果这个字母是元音,而它前面的字母是辅音
			if((s.charAt(i)=='a'||s.charAt(i)=='e'||s.charAt(i)=='i'||s.charAt(i)=='o'||s.charAt(i)=='u')&&!flag) {
				sum++;
				flag=true;
			}
			//如果这个字母是辅音,而它前面的字母是元音
			if(s.charAt(i)!='a'&&s.charAt(i)!='e'&&s.charAt(i)!='i'&&s.charAt(i)!='o'&&s.charAt(i)!='u'&&flag) {
				sum++;
				flag=false;
			}
		}
		if(sum==3) {
			System.out.println("yes");
		}
		else {
			System.out.println("no");
		}
	}
}

	

(7)

问题描述
  在数列 a[1], a[2], ..., a[n] 中,如果对于下标 i, j, k 满足 0<i<j<k<n+1 且 a[i]<a[j]<a[k],则称 a[i], a[j], a[k] 为一组递增三元组,a[j]为递增三元组的中心。
  给定一个数列,请问数列中有多少个元素可能是递增三元组的中心。
输入格式
  输入的第一行包含一个整数 n。
  第二行包含 n 个整数 a[1], a[2], ..., a[n],相邻的整数间用空格分隔,表示给定的数列。
输出格式
  输出一行包含一个整数,表示答案。
样例输入
5
1 2 5 3 5
样例输出
2
样例说明
  a[2] 和 a[4] 可能是三元组的中心。
评测用例规模与约定
  对于 50% 的评测用例,2 <= n <= 1000 <= 数列中的数 <= 1000。
  对于所有评测用例,2 <= n <= 10000 <= 数列中的数 <= 10000

暴力法就是对每一个数字向左边和右边进行搜索,可以得一半分,不过这题正确解法是创建一个最大值数组和最小值数组,线性扫描下,然后判断small[i]


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

public class Main {
	public static void main(String[] args) throws  IOException {
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		int n=Integer.valueOf(br.readLine());
		int[] arr=new int[n];
		String[] s=br.readLine().split(" ");
		for(int i=0;i<n;i++) {
			arr[i]=Integer.valueOf(s[i]);
		}
		int[] big=new int[n];
		int[] small=new int[n];
		big[0]=arr[0];
		small[0]=arr[0];
		for(int i=1;i<n;i++) {
			if(arr[i]<small[i-1]) {
				small[i]=arr[i];
			}
			if(arr[i]>big[i-1]) {
				big[i]=arr[i];
			}
		}
		int sum=0;
		for(int i=1;i<n-1;i++) {
			if(small[i-1]<arr[i]&&arr[i]<big[i+1]) {
				sum++;
			}
		}
		System.out.println(sum);
	}
}


	

(8)

问题描述
  小明想知道,满足以下条件的正整数序列的数量:
  1. 第一项为 n;
  2. 第二项不超过 n;
  3. 从第三项开始,每一项小于前两项的差的绝对值。
  请计算,对于给定的 n,有多少种满足条件的序列。
输入格式
  输入一行包含一个整数 n。
输出格式
  输出一个整数,表示答案。答案可能很大,请输出答案除以10000的余数。
样例输入
4
样例输出
7
样例说明
  以下是满足条件的序列:
  4 1
  4 1 1
  4 1 2
  4 2
  4 2 1
  4 3
  4 4
评测用例规模与约定
  对于 20% 的评测用例,1 <= n <= 5;
  对于 50% 的评测用例,1 <= n <= 10;
  对于 80% 的评测用例,1 <= n <= 100;
  对于所有评测用例,1 <= n <= 1000

这题,先暴力一下,数据也不是很大,1000以内肯定能找完,再用打表法时间复杂度o(1)。



import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		int n=sc.nextInt();
		int[] arr={0,1, 2, 4, 7, 14, 26, 53, 106, 220, 452, 946, 1967, 4128, 8638, 8144, 8068, 26, 8127, 3542, 3277, 3278, 7643, 5433, 5774, 8217, 4846, 687, 3097, 6887, 3556, 4840, 3454, 5378, 722, 2230, 767, 1447, 1839, 4776, 7618, 7831, 6222, 5236, 7802, 5696, 1835, 1102, 9537, 1605, 1227, 3034, 2159, 1613, 6811, 3941, 6794, 5960, 4903, 75, 2158, 349, 4258, 5189, 4717, 2894, 4193, 2890, 258, 2928, 6125, 2913, 1482, 8419, 7244, 1652, 3440, 2138, 9272, 4714, 3333, 3543, 8834, 6763, 9180, 1803, 4631, 6307, 9056, 3170, 8339, 6213, 1176, 3258, 272, 4257, 1893, 8020, 3682, 9531, 6961, 4145, 3086, 3455, 9057, 1346, 5768, 6907, 247, 2450, 4732, 8653, 8229, 842, 3346, 9671, 7106, 3561, 4952, 9539, 1791, 6208, 6083, 8838, 7474, 6854, 198, 7300, 8219, 5912, 8884, 3976, 9650, 4821, 7317, 9720, 5572, 3834, 6326, 2281, 34, 8409, 28, 445, 8155, 9846, 9944, 2504, 3954, 1639, 7243, 8502, 6926, 1609, 7449, 3769, 5695, 6683, 7531, 6275, 5827, 6184, 1982, 736, 9718, 2777, 7688, 6626, 7456, 961, 5556, 7573, 6886, 4543, 3957, 2859, 4666, 9795, 305, 9052, 5350, 9827, 5445, 6970, 2599, 7566, 2848, 2987, 5179, 1537, 2392, 6375, 9621, 7376, 3301, 1357, 6545, 7838, 9390, 4284, 2631, 1814, 2566, 7666, 1110, 5694, 7595, 5000, 1290, 4735, 5994, 9401, 6475, 9012, 5877, 2867, 7912, 3509, 5505, 885, 7490, 5622, 4374, 8721, 5134, 8788, 5430, 3869, 9852, 5762, 75, 5964, 262, 5565, 1599, 7525, 5388, 8612, 1143, 7938, 7580, 2953, 7901, 5629, 1456, 9852, 5216, 965, 3739, 7879, 1212, 9029, 9263, 9609, 1926, 8151, 1997, 6298, 5125, 5715, 4864, 3852, 604, 7652, 313, 6248, 4077, 3875, 3816, 7046, 9525, 3798, 6959, 9366, 2216, 4463, 6546, 6367, 614, 9477, 3176, 4098, 7162, 7535, 4696, 749, 2686, 8212, 9050, 255, 1389, 287, 1086, 9414, 9897, 2293, 31, 9121, 4682, 7084, 8951, 834, 1051, 2236, 3712, 6426, 8642, 185, 785, 8162, 6015, 658, 8923, 5741, 2551, 7629, 2095, 8882, 7695, 5629, 8684, 5116, 6362, 7701, 9441, 9403, 1108, 4395, 5688, 9466, 953, 9191, 4967, 7236, 6020, 3465, 8165, 872, 4530, 3353, 7859, 1422, 1504, 6366, 126, 1246, 1530, 1777, 8970, 4590, 2195, 6920, 9086, 689, 2163, 6035, 4961, 2055, 7699, 4121, 3971, 1824, 3707, 4405, 854, 6088, 6971, 1679, 1779, 7097, 5696, 2449, 2104, 3264, 796, 8595, 6183, 26, 5597, 7295, 5926, 9039, 4550, 9601, 5959, 3244, 7451, 5641, 2343, 6587, 3755, 4361, 3890, 446, 8187, 1979, 7000, 7094, 8658, 1647, 6090, 8332, 4407, 4570, 2340, 3057, 5029, 5424, 2736, 4844, 2771, 5782, 5912, 3745, 2504, 2782, 7247, 1393, 5403, 7175, 9903, 1723, 7600, 7021, 4566, 9778, 5188, 46, 8542, 7915, 5043, 4983, 519, 480, 8199, 1141, 73, 9316, 6248, 966, 3218, 6614, 6974, 5078, 9775, 7263, 6263, 7267, 1947, 5357, 286, 674, 3876, 1985, 4731, 1850, 512, 1493, 5310, 5443, 4183, 5963, 8642, 1389, 6320, 4264, 9565, 7348, 4378, 6192, 1300, 3393, 4794, 8323, 6063, 9651, 9368, 7899, 9053, 4933, 5140, 5604, 9114, 9299, 7603, 2485, 884, 7313, 4139, 9883, 1405, 9843, 7419, 1483, 2031, 8610, 4150, 3313, 6257, 3790, 1688, 994, 1357, 9660, 583, 5735, 1548, 7156, 9678, 8047, 3617, 9611, 7966, 7764, 5177, 7716, 4206, 7985, 6989, 6318, 5854, 8292, 9639, 687, 370, 3252, 7104, 5813, 758, 8219, 3809, 2506, 3605, 9340, 3559, 4118, 4757, 8229, 4258, 944, 1596, 4940, 622, 5832, 1270, 6948, 1744, 1125, 7895, 9348, 7601, 7426, 1975, 9611, 3722, 4143, 4979, 7904, 3221, 3817, 5755, 1798, 6549, 3463, 3190, 201, 6894, 6209, 3488, 670, 7643, 7020, 6164, 5583, 5036, 6309, 8644, 7961, 3465, 7795, 1486, 4535, 3111, 5252, 4049, 4253, 7515, 1517, 6148, 2438, 1296, 8826, 7924, 7761, 9126, 6951, 7110, 7549, 1170, 8533, 793, 1633, 6451, 6261, 5887, 8694, 6447, 8993, 6398, 1289, 2925, 2362, 3935, 6744, 1358, 1743, 3937, 9942, 3696, 1601, 8295, 3086, 2595, 9554, 8566, 1465, 2109, 3474, 3950, 9216, 8948, 2020, 3536, 943, 4934, 8377, 6171, 1243, 3525, 259, 3001, 4205, 4548, 4754, 2365, 8630, 4690, 7872, 5131, 3995, 2672, 728, 6532, 9785, 9379, 5865, 4774, 6660, 3721, 4451, 9085, 4771, 8008, 857, 9737, 5630, 4040, 3106, 5997, 4152, 8542, 3992, 3294, 5064, 2656, 5247, 635, 1521, 3026, 1502, 9396, 2171, 7188, 2425, 9758, 2640, 8648, 9454, 274, 9471, 8972, 9301, 911, 6023, 4155, 126, 7802, 2948, 5675, 6313, 69, 1374, 9925, 3685, 6901, 432, 1884, 4803, 8173, 9638, 3626, 695, 4286, 3836, 8670, 8834, 1444, 5187, 6281, 2482, 8801, 7656, 9066, 5138, 5160, 9857, 906, 5235, 7243, 5281, 5103, 5826, 5023, 3637, 5607, 1204, 5697, 3422, 1192, 8753, 6087, 2083, 3256, 8201, 9853, 1886, 3953, 4732, 7351, 6387, 9148, 2299, 4843, 3891, 3572, 874, 9873, 1235, 7323, 8860, 3439, 113, 5132, 6521, 1234, 7427, 4062, 1342, 2480, 641, 8802, 9788, 5336, 3649, 1301, 3268, 749, 1628, 9202, 2689, 3284, 9170, 5252, 1577, 1705, 5640, 2185, 2252, 4943, 271, 5117, 8699, 2743, 8221, 2119, 3851, 701, 2740, 4247, 7037, 9764, 4445, 5848, 6135, 6166, 5328, 2584, 1131, 3005, 8817, 2783, 7749, 6112, 5567, 9688, 2549, 7929, 8650, 60, 1896, 3998, 7345, 3352, 8990, 1143, 873, 1191, 5821, 9485, 5249, 3086, 8016, 9319, 4139, 3566, 8871, 7528, 7873, 4117, 1085, 7064, 8222, 5947, 4447, 1326, 5206, 12, 9703, 5711, 3951, 219, 6966, 3168, 2372, 9603, 9092, 1904, 1010, 2704, 2106, 7568, 3410, 296, 6825, 9781, 637, 4465, 7953, 6861, 2142, 2035, 9743, 1921, 3051, 7424, 7112, 7676, 5245, 9531, 2284, 4498, 6423, 6977, 3106, 1367, 5696, 2003, 1291, 3025, 76, 3147, 9094, 4580, 5097, 7390, 8637, 5853, 359, 3153, 4957, 6635, 5721, 3353, 2266, 3481, 7432, 3020, 7330, 1172, 5285, 1525, 2928, 5331, 8856, 2163, 5169, 1465, 4439, 1876, 7446, 2192, 5577, 726, 6599, 352, 3645, 7733, 8331, 5447, 8017, 5017, 7287, 6602, 7248, 6323, 4195, 9617, 2263, 4013, 450, 4073, 6131, 3569, 9019, 1858, 9827, 8118, 4972, 7422, 9666, 5760, 9213, 2817, 7952, 3948, 8683, 3645, 6402, 3264, 1919, 9276, 2519, 190, 766, 8940, 3413, 2644, 8048, 83, 9724, 7009, 3777, 9663, 2483, 5752, 4578, 8951, 5902, 2170, 9967, 894, 8556, 6049, 7254, 2746, 8962, 8317, 6848, 767, 7907, 1028, 9458, 6881, 4978, 6717, 8210, 3835, 1064,7434, 746, 9449};
		System.out.println(arr[n]);
	}
}
	

(9)

问题描述
  小明有一块空地,他将这块空地划分为 n 行 m 列的小块,每行和每列的长度都为 1。
  小明选了其中的一些小块空地,种上了草,其他小块仍然保持是空地。
  这些草长得很快,每个月,草都会向外长出一些,如果一个小块种了草,则它将向自己的上、下、左、右四小块空地扩展,这四小块空地都将变为有草的小块。
  请告诉小明,k 个月后空地上哪些地方有草。
输入格式
  输入的第一行包含两个整数 n, m。
  接下来 n 行,每行包含 m 个字母,表示初始的空地状态,字母之间没有空格。如果为小数点,表示为空地,如果字母为 g,表示种了草。
  接下来包含一个整数 k。
输出格式
  输出 n 行,每行包含 m 个字母,表示 k 个月后空地的状态。如果为小数点,表示为空地,如果字母为 g,表示长了草。
样例输入
4 5
.g...
.....
..g..
.....
2
样例输出
gggg.
gggg.
ggggg
.ggg.
评测用例规模与约定
  对于 30% 的评测用例,2 <= n, m <= 20。
  对于 70% 的评测用例,2 <= n, m <= 100。
  对于所有评测用例,2 <= n, m <= 10001 <= k <= 1000

暴力法就是遍历k次地图,每次给有草的上下左右加草,当然不能同时进行,要先判断有没有草,用一个二维数组记录,然后再加草。可以过70%数据

正确做法用bfs,对每个有草的点进行bfs


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;

public class Main {
	static int n,m,k;
	static char[][] map=new char[1010][1010];
	static char[][] res=new char[1010][1010];
	static int[][] vis=new int[1010][1010];
	static int[] dir_x= {1,-1,0,0};
	static int[] dir_y= {0,0,1,-1};
	public static void bfs(int x,int y){
		Queue<node> q=new LinkedList<node>();
		q.add(new node(x,y,0));
		vis[x][y]=0;
		while(!q.isEmpty()) {
			node now=q.remove();
			for(int i=0;i<4;i++) {
				int tx=now.x+dir_x[i];
				int ty=now.y+dir_y[i];
				int td=now.d+1;
				if(0<=tx&&tx<n&&0<=ty&&ty<m&&td<vis[tx][ty]&&td<=k) {
					q.add(new node(tx,ty,td));
					res[tx][ty]='g';
					vis[tx][ty]=td;
				}
			}
		}
	}
	public static void main(String[] args) throws  IOException {
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		String[] s=br.readLine().split(" ");
		n=Integer.valueOf(s[0]);
		m=Integer.valueOf(s[1]);
		for(int i=0;i<n;i++) {
			map[i]=br.readLine().toCharArray();
			res[i]=Arrays.copyOf(map[i],map[i].length);
		}
		k=Integer.valueOf(br.readLine());
		for(int i=0;i<n;i++)
			for(int j=0;j<m;++j)
			if(map[i][j]=='g') {
				for(int z=0;z<n;z++) {
					Arrays.fill(vis[z], 1000);
				}
				bfs(i,j);
			}
			for(int i=0;i<n;++i) {
				for(int j=0;j<m;j++) {
					System.out.print(res[i][j]);
				}
				System.out.println();
			}
		}
}
class node{
	int x;
	int y;
	int d;
	node(int xx,int yy,int dd){
		x=xx;
		y=yy;
		d=dd;
	}
}
	

(10)

输入格式
  输入的第一行包含两个整数 n, m ,表示节目的数量和要选择的数量。
  第二行包含 n 个整数,依次为每个节目的好看值。
输出格式
  输出一行包含 m 个整数,为选出的节目的好看值。
样例输入
5 3
3 1 2 5 4
样例输出
3 5 4
样例说明
  选择了第1, 4, 5个节目。
评测用例规模与约定
  对于 30% 的评测用例,1 <= n <= 20;
  对于 60% 的评测用例,1 <= n <= 100;
  对于所有评测用例,1 <= n <= 1000000 <= 节目的好看值 <= 100000

代码很简单,思路很难想,就是排序两遍,第一遍排序按照分数排序,取前m个人,再用编号排序即可


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

public class Main {
	public static void main(String[] args) throws IOException {
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		String[] s=br.readLine().split(" ");
		int n=Integer.valueOf(s[0]),m=Integer.valueOf(s[1]);
		s=br.readLine().split(" ");
		p[] arr=new p[n];
		for(int i=0;i<n;i++) {
			arr[i]=new p(i,Integer.valueOf(s[i]));
		}
		MyComparator1 cmp1=new MyComparator1();
		MyComparator2 cmp2=new MyComparator2();
		Arrays.sort(arr,cmp1);
		p[] arr2=Arrays.copyOf(arr, m);
		
		Arrays.sort(arr2,cmp2);
		for(int i=0;i<m;i++) {
			System.out.print(arr2[i].score+" ");
		}
	}
}
class p{
	int id;
	int score;
	p(int id,int score){
		this.id=id;
		this.score=score;
	}
}
class MyComparator1 implements Comparator<p>{
	@Override
	public int compare(p o1, p o2) {
		return o2.score-o1.score;
	}
	
}
class MyComparator2 implements Comparator<p>{
	@Override
	public int compare(p o1, p o2) {
		return o1.id-o2.id;
	}
	
}

	

你可能感兴趣的:(蓝桥杯练习系统题解)