模拟赛
我的18号上午的比赛，题目顺序和一些细节可能和现在网上的不一样。我是按照我的顺序写的。
因为不能直接提交判题，所以我也不知道我写的对不对，发现不对的请评论区指正。
做之前我也没想到蓝桥杯还可以有填空题，这种就不用受运行时间和内存的限制了，想怎么跑就怎么跑，不用担心超时了。
1200000的约数
问题描述
1200000有多少个约数（只计算正约数）。
答案提交
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
废话不多说直接暴力出奇迹。
public class Main {
public static void main(String[] args) {
int sum=0;
for(int i=1;i<=1200000;i++) {
if(1200000%i==0) {
sum++;
}
}
System.out.println(sum);
}
}
GB转MB
问题描述
在计算机存储中，15.125GB是多少MB？
答案提交
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
1GB = 1024MB，15.125 ✖ 1024 = 15488，计算器就搞定
多少个9
问题描述
在1至2019中，有多少个数的数位中包含数字9？
注意，有的数中的数位中包含多个9，这个数只算一次。例如，1999这个数包含数字9，在计算只是算一个数。
答案提交
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
依旧暴力，从1到2019，只不过把每个数字都转成字符串，然后调用contains方法，看字符串内是否包含9即可。
public class Main {
public static void main(String[] args) {
int count = 0;
for (int i = 1; i <= 2019; i++) {
String s = i+"";
if (s.contains("9"))
count++;
}
System.out.println(count);
}
}
2019个结点的二叉树
问题描述
一棵包含有2019个结点的二叉树，最多包含多少个叶结点？
答案提交
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
这个与网上的不一样，这次指定为二叉树。先假设与现在二叉树最接近的满二叉树有多少个结点，有多少层，最后一层多少个结点。
推出最后一层实际有多少，加上上一层无子结点的结点（可惜我少了这一步啊），即为答案。
n为层数，满二叉树的结点总数为2n-1，单层的结点数为2n-1。
因此最接近2019个结点的满二叉树是11层，211-1 = 2047，211-1 = 1024
2047-2019 = 28，所以跟满二叉树比是少了28个叶子结点，也就是说第10层有14个结点无子节点。
前10层共有210-1 = 1023个结点，所以11层有2019-1023 = 996个叶子结点
加上14，共有1010个叶子结点
递增三元组的中心
问题描述
在数列 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 <= 100，0 <= 数列中的数 <= 1000。
对于所有评测用例，2 <= n <= 1000，0 <= 数列中的数 <= 10000。
满脑子只有遍历了，但是这里有个注意点，一个索引只能记一次数，就是说同一个j即使满足多种情况也只能算一个。
这样满足一种情况，就可以continue j的那一层了
还有一些特殊情况，一样可以continue
import java.io.BufferedInputStream;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(new BufferedInputStream(System.in));
int n = sc.nextInt();
int[] arr = new int[n];
for (int i = 0; i < arr.length; i++) {
arr[i] = sc.nextInt();
}
int count = 0;
for (int i = 0; i <= n - 3; i++) {
middle:
for (int j = i + 1; j <= n - 2; j++) {
for (int k = j + 1; k <= n - 1; k++) {
if (arr[i] < arr[j] && arr[j] < arr[k]) {
count++;
continue middle;
} else if (arr[i] >= arr[j]) {
continue middle;
} else if (arr[i] < arr[j] && arr[j] >= arr[k]) {
continue;
}
}
}
}
System.out.println(count);
}
}
还有大佬给了另一种思路和代码，我没理解，理解的可以滴滴我。
//创建一个最大值数组和最小值数组，线性扫描下，然后判断small[i]<now[i]<big[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);
}
}
————————————————
版权声明：本文为CSDN博主「掌握核心科技」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_43751506/article/details/104860887
数位递增
问题描述
一个正整数如果任何一个数位不大于右边相邻的数位，则称为一个数位递增的数，例如1135是一个数位递增的数，而1024不是一个数位递增的数。
给定正整数 n，请问在整数 1 至 n 中有多少个数位递增的数？
输入格式
输入的第一行包含一个整数 n。
输出格式
输出一行包含一个整数，表示答案。
样例输入
30
样例输出
26
评测用例规模与约定
对于 40% 的评测用例，1 <= n <= 1000。
对于 80% 的评测用例，1 <= n <= 100000。
对于所有评测用例，1 <= n <= 1000000。
我的想法很简单，把数字转成字符串，再转成字符数组，用Arrays.sort进行排序，然后在转成字符串，和原来的进行equals比较，如果相等就是不等就不是。
因为字符也是可以比大小的嘛，题目上的递增数就是升序的一个字符序列，那么对字符数组进行排序（排序后是升序）看是否改变了顺序就能说明是否为递增数了。
就是不知道这个方法对不对。
import java.io.BufferedInputStream;
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static boolean isNumber(String s) {
char[] chars = s.toCharArray();
Arrays.sort(chars);
if (s.equals(new String(chars)))
return true;
else
return false;
}
public static void main(String[] args) {
Scanner sc = new Scanner(new BufferedInputStream(System.in));
int n = sc.nextInt();
int count = 1;
for (int i = 2; i <= n; i++) {
if (isNumber(i+""))
count++;
}
System.out.println(count);
}
}
其他大佬有用暴力的，有用数位dp的，原谅我真的想不到。
元音辅音单词
问题描述
小明对类似于 hello 这种单词非常感兴趣，这种单词可以正好分为四段，第一段由一个或多个辅音字母组成，第二段由一个或多个元音字母组成，第三段由一个或多个辅音字母组成，第四段由一个或多个元音字母组成。
给定一个单词，请判断这个单词是否也是这种单词，如果是请输出yes，否则请输出no。
元音字母包括 a, e, i, o, u，共五个，其他均为辅音字母。
输入格式
输入一行，包含一个单词，单词中只包含小写英文字母。
输出格式
输出答案，或者为yes，或者为no。
样例输入
lanqiao
样例输出
yes
样例输入
world
样例输出
no
评测用例规模与约定
对于所有评测用例，单词中的字母个数不超过100。
一个字母不是元音就是辅音，其实不管什么字母就是两种状态，那么我们可以把他看成T/F，1/0，元音为1辅音为0。
一个单词由元音字母和辅音字母组成，那我们可以把单词转为一个01构成的字符串。
那么这种特殊单词就要满足以下格式
至少一个0 + 只要一个1 + 至少一个0 + 至少一个1
我能想到的最方便的方法就是正则表达式匹配，用str.matcher(regex)方法，在里面写上匹配格式。
* 对前面字符匹配0次或者无限次
+ 对前面字符匹配1次或者无限次
? 对前面字符匹配0次或者1次
格式标准如上，所以匹配格式就是0+1+0+1+
不太知道这个方法会不会超时什么的。
import java.io.BufferedInputStream;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(new BufferedInputStream(System.in));
String word = sc.next();
char[] charsWord = word.toCharArray();
String s = "";
for (int i = 0; i < charsWord.length; i++) {
//元音为1，辅音为0
switch (charsWord[i]) {
case 'a':
case 'e':
case 'i':
case 'o':
case 'u':
s+=1;
break;
default:
s+=0;
break;
}
}
if (s.matches("0+1+0+1+"))
System.out.println("yes");
else
System.out.println("no");
}
}
同样还有其他大佬的思路，有的是用遍历，有的是用一个状态开关。
满足格式的单词的第一个字母必定是辅音，状态开关转换表示后面的是元音还是辅音，并用一个变量计算变换的次数。
整个单词遍历后，如果变换了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");
}
}
}
————————————————
版权声明：本文为CSDN博主「掌握核心科技」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_43751506/article/details/104860887
小明的空地
问题描述
小明有一块空地，他将这块空地划分为 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 <= 1000，1 <= k <= 1000。
这个我只能看出来是bfs，代码不知道怎么搞，还是问的朋友，就不给大家讲了，因为我也没看完代码。
import java.io.BufferedInputStream;
import java.util.LinkedList;
import java.util.Scanner;
public class Main8 {
static int maxn = 1010, d[][] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
static char bd[][] = new char[maxn][];
static LinkedList<Integer> list = new LinkedList<>();
static boolean vis[][] = new boolean[maxn][maxn];
static void bfs(int k, int n, int m) {
while (!list.isEmpty()) {
int x = list.poll();
int y = list.poll();
int c = list.poll();
//System.out.println(x+" "+y);
if (c == k) continue;
for (int i = 0; i < 4; i++) {
int xx = x + d[i][0];
int yy = y + d[i][1];
if (xx >= n || yy >= m || xx < 0 || yy < 0 || vis[xx][yy]) continue;
//System.out.println(xx+" "+yy);
bd[xx][yy] = 'g';
list.add(xx);
list.add(yy);
list.add(c + 1);
}
}
}
public static void main(String args[]) {
Scanner sc = new Scanner(new BufferedInputStream(System.in));
int n = sc.nextInt();
int m = sc.nextInt();
sc.nextLine();
for (int i = 0; i < n; i++) {
bd[i] = sc.nextLine().toCharArray();
for (int j = 0; j < m; j++) {
if (bd[i][j] == 'g') {
//System.out.println(i+" "+j);
list.add(i);
list.add(j);
list.add(0);
vis[i][j] = true;
}
}
}
int k = sc.nextInt();
bfs(k, n, m);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
System.out.print(bd[i][j]);
}
System.out.println();
}
}
}
特殊的正整数序列
问题描述
小明想知道，满足以下条件的正整数序列的数量：
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。
小明的事还真的是多，这个题我完全不会。不过看样例看出了点递归的想法，可是因为数据范围我怕爆栈或超时就放弃了递归，虽然50%内的范围还是比较小的。可以先用递归写拿一半分。
这个还要问问朋友，再自己写。
有个大佬说直接暴力打表，我也是蒙了，问他打表的方法吧。
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]);
}
}
————————————————
版权声明：本文为CSDN博主「掌握核心科技」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_43751506/article/details/104860887
晚会节目
问题描述
小明要组织一台晚会，总共准备了 n 个节目。然后晚会的时间有限，他只能最终选择其中的 m 个节目。
这 n 个节目是按照小明设想的顺序给定的，顺序不能改变。
小明发现，观众对于晚上的喜欢程度与前几个节目的好看程度有非常大的关系，他希望选出的第一个节目尽可能好看，在此前提下希望第二个节目尽可能好看，依次类推。
小明给每个节目定义了一个好看值，请你帮助小明选择出 m 个节目，满足他的要求。
输入格式
输入的第一行包含两个整数 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 <= 100000，0 <= 节目的好看值 <= 100000。
这个不是很难，创建一个节目对象存储好感度和索引值。
排序两次，第一次按照好感度降序排序。选出好感度排名前m的节目。
这时候不能直接输出，因为输出是要按照原顺序的。
再对选出来的m个节目的索引值进行升序排序，还原他们的先后顺序。（我忘了这一步唉）
接下来对他们的好感度进行输出。
import java.io.BufferedInputStream;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;
public class Main10 {
public static void main(String[] args) {
Scanner sc = new Scanner(new BufferedInputStream(System.in));
int n = sc.nextInt();
int m = sc.nextInt();
Node[] rep = new Node[n];
for (int i = 0; i < rep.length; i++) {
rep[i] = new Node(sc.nextInt(), i);
}
Node[] tmp = rep.clone();
Arrays.sort(tmp, new MyComparator1());
Node[] tmp2 = Arrays.copyOf(tmp,m);
Arrays.sort(tmp2, new MyComparator2());
for (int i = 0; i < tmp2.length; i++) {
if (i!=m-1)
System.out.print(tmp2[i].data+" ");
else
System.out.print(tmp2[i].data);
}
}
static class Node {
int data;
int index;
public Node(int data, int index) {
this.data = data;
this.index = index;
}
}
static class MyComparator1 implements Comparator<Node> {
@Override
public int compare(Node o1, Node o2) {
return o2.data-o1.data;
}
}
static class MyComparator2 implements Comparator<Node>{
@Override
public int compare(Node o1, Node o2) {
return o1.index-o2.index;
}
}
}
唉真是难为死我了，给个赞吧。
转载：https://blog.csdn.net/qq_41718454/article/details/104944724