蓝桥杯真题2017-2021
刷完近几年真题，感觉理解完之后，拿奖问题不大，本人这次获得2022年蓝桥杯javaB组省一，以下是历年javaB组省赛题目。
文章目录
- 2017年真题
- 一、购物单
- 二、纸牌三角形
- 三、承压计算
- 四、魔方状态
- 五、取数位
- 六、最大公共子串
- 七、日期问题
- 八、包子凑数
- 九、分巧克力
- 十、k倍区间
- 小结
- 2018年真题
- 一、第几天
- 二、方格计数
- 三、复数幂
- 四、测试次数
- 九、全球变暖
- 十、堆的计数
- 2019年真题
- 01-试题 A: 组队
- 02-试题 B: 不同子串
- 03-试题 C: 数列求值
- 04-试题 D: 数的分解
- 05-试题 E: 迷宫
- 06-试题 F: 特别数的和
- 07-试题 G: 外卖店优先级
- 08-试题 H: 人物相关性分析
- 09-试题 I: 后缀表达式
- 10-试题 J: 灵能传输
- 2020年第二场真题
- 一、试题 A: 门牌制作——答案：641
- 二、试题 B: 寻找 2020——答案：16520
- 三、试题 C: 蛇形填数——答案：761
- 四、试题 D: 七段码——答案：80
- 五、试题 E: 排序——jonmlkihgfedcba
- 六、试题 F: 成绩分析
- 7单词分析
- 八、试题 H: 数字三角形3
- 九、试题 I: 子串分值和
- 2021年真题
- 试题A:ASC
- Q2卡片
- q3直线
- q4货物摆放
- Q5路径
- q6时间显示
- q7最小砝码
- q8杨辉三角
- q9双向排序
- q10括号序列
- q7最小砝码
- q8杨辉三角
- q9双向排序
- q10括号序列
2017年真题
一、购物单
标题： 购物单小明刚刚找到工作，老板人很好，只是老板夫人很爱购物。老板忙的时候经常让小明帮忙到商场代为购物。小明很厌烦，但又不好推辞。这不，XX大促销又来了！老板夫人开出了长长的购物单，都是有打折优惠的。小明也有个怪癖，不到万不得已，从不刷卡，直接现金搞定。现在小明很心烦，请你帮他计算一下，需要从取款机上取多少现金，才能搞定这次购物。取款机只能提供100元面额的纸币。小明想尽可能少取些现金，够用就行了。你的任务是计算出，小明最少需要取多少现金。以下是让人头疼的购物单，为了保护隐私，物品名称被隐藏了。
-----------------
**** 180.90 88折
**** 10.25 65折
**** 56.14 9折
**** 104.65 9折
**** 100.30 88折
**** 297.15 半价
**** 26.75 65折
**** 130.62 半价
**** 240.28 58折
**** 270.62 8折
**** 115.87 88折
**** 247.34 95折
**** 73.21 9折
**** 101.00 半价
**** 79.54 半价
**** 278.44 7折
**** 199.26 半价
**** 12.97 9折
**** 166.30 78折
**** 125.50 58折
**** 84.98 9折
**** 113.35 68折
**** 166.57 半价
**** 42.56 9折
**** 81.90 95折
**** 131.78 8折
**** 255.89 78折
**** 109.17 9折
**** 146.69 68折
**** 139.33 65折
**** 141.16 78折
**** 154.74 8折
**** 59.42 8折
**** 85.44 68折
**** 293.70 88折
**** 261.79 65折
**** 11.30 88折
**** 268.27 58折
**** 128.29 88折
**** 251.03 8折
**** 208.39 75折
**** 128.88 75折
**** 62.06 9折
**** 225.87 75折
**** 12.89 75折
**** 34.28 75折
**** 62.16 58折
**** 129.12 半价
**** 218.37 半价
**** 289.69 8折
--------------------需要说明的是，88折指的是按标价的88%计算，而8折是按80%计算，余者类推。
特别地，半价是按50%计算。请提交小明要从取款机上提取的金额，单位是元。
答案是一个整数，类似4300的样子，结尾必然是00，不要填写任何多余的内容。特别提醒：不许携带计算器入场，也不能打开手机。
使用excel进行计算！
5200
二、纸牌三角形
标题：纸牌三角形
A,2,3,4,5,6,7,8,9 共9张纸牌排成一个正三角形（A按1计算）。要求每个边的和相等。
下图就是一种排法（如有对齐问题，参看p1.png）。
p1.png
A
9 6
4 8
3 7 5 2
这样的排法可能会有很多。
如果考虑旋转、镜像后相同的算同一种，一共有多少种不同的排法呢？
请你计算并提交该数字。
注意：需要提交的是一个整数，不要提交任何多余内容。
解题思路：
全排列+条件判断+去重
因为一个排法形成的正三角形会有旋转、镜像两种可能
首先一个三角形有三种旋转，每种旋转有两个镜像，所以一个情况有6种重复！！
最后ans/6
package q2017;import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;public class q2纸牌三角形 {static int[] a={1,2,3,4,5,6,7,8,9};static int cnt;static Map<Integer,Integer> map=new HashMap<>();public static void main(String[] args) {f(a,0);System.out.println(cnt/6);}public static void f(int []a,int k){if (k==a.length){int x=a[0]+a[1]+a[3]+a[5];int y=a[0]+a[2]+a[4]+a[8];int z=a[5]+a[6]+a[7]+a[8];if (x==y&&y==z){// if (map.get(x)==null){// map.put(x,1);
// cnt++;
// }cnt++;}}for(int i=k;i<a.length;i++){int t=a[i];a[i]=a[k];a[k]=t;f(a,k+1);t=a[i];a[i]=a[k];a[k]=t;}}
}
三、承压计算
标题：承压计算X星球的高科技实验室中整齐地堆放着某批珍贵金属原料。每块金属原料的外形、尺寸完全一致，但重量不同。
金属材料被严格地堆放成金字塔形。7 5 8 7 8 8 9 2 7 2 8 1 4 9 1 8 1 8 8 4 1 7 9 6 1 4 5 4 5 6 5 5 6 9 5 6 5 5 4 7 9 3 5 5 1 7 5 7 9 7 4 7 3 3 1 4 6 4 5 5 8 8 3 2 4 3 1 1 3 3 1 6 6 5 5 4 4 2 9 9 9 2 1 9 1 9 2 9 5 7 9 4 3 3 7 7 9 3 6 1 3 8 8 3 7 3 6 8 1 5 3 9 5 8 3 8 1 8 3 3 8 3 2 3 3 5 5 8 5 4 2 8 6 7 6 9 8 1 8 1 8 4 6 2 2 1 7 9 4 2 3 3 4 2 8 4 2 2 9 9 2 8 3 4 9 6 3 9 4 6 9 7 9 7 4 9 7 6 6 2 8 9 4 1 8 1 7 2 1 6 9 2 8 6 4 2 7 9 5 4 1 2 5 1 7 3 9 8 3 3 5 2 1 6 7 9 3 2 8 9 5 5 6 6 6 2 1 8 7 9 9 6 7 1 8 8 7 5 3 6 5 4 7 3 4 6 7 8 1 3 2 7 4 2 2 6 3 5 3 4 9 2 4 5 7 6 6 3 2 7 2 4 8 5 5 4 7 4 4 5 8 3 3 8 1 8 6 3 2 1 6 2 6 4 6 3 8 2 9 6 1 2 4 1 3 3 5 3 4 9 6 3 8 6 5 9 1 5 3 2 6 8 8 5 3 2 2 7 9 3 3 2 8 6 9 8 4 4 9 5 8 2 6 3 4 8 4 9 3 8 8 7 7 7 9 7 5 2 7 9 2 5 1 9 2 6 5 3 9 3 5 7 3 5 4 2 8 9 7 7 6 6 8 7 5 5 8 2 4 7 7 4 7 2 6 9 2 1 8 2 9 8 5 7 3 6 5 9 4 5 5 7 5 5 6 3 5 3 9 5 8 9 5 4 1 2 6 1 4 3 5 3 2 4 1
X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X 其中的数字代表金属块的重量（计量单位较大）。
最下一层的X代表30台极高精度的电子秤。假设每块原料的重量都十分精确地平均落在下方的两个金属块上，
最后，所有的金属块的重量都严格精确地平分落在最底层的电子秤上。
电子秤的计量单位很小，所以显示的数字很大。工作人员发现，其中读数最小的电子秤的示数为：2086458231请你推算出：读数最大的电子秤的示数为多少？注意：需要提交的是一个整数，不要填写任何多余的内容。
package q2017;import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Scanner;/*75 87 8 89 2 7 28 1 4 9 18 1 8 8 4 17 9 6 1 4 5 45 6 5 5 6 9 5 65 5 4 7 9 3 5 5 17 5 7 9 7 4 7 3 3 14 6 4 5 5 8 8 3 2 4 31 1 3 3 1 6 6 5 5 4 4 29 9 9 2 1 9 1 9 2 9 5 7 94 3 3 7 7 9 3 6 1 3 8 8 3 73 6 8 1 5 3 9 5 8 3 8 1 8 3 38 3 2 3 3 5 5 8 5 4 2 8 6 7 6 98 1 8 1 8 4 6 2 2 1 7 9 4 2 3 3 42 8 4 2 2 9 9 2 8 3 4 9 6 3 9 4 6 97 9 7 4 9 7 6 6 2 8 9 4 1 8 1 7 2 1 69 2 8 6 4 2 7 9 5 4 1 2 5 1 7 3 9 8 3 35 2 1 6 7 9 3 2 8 9 5 5 6 6 6 2 1 8 7 9 96 7 1 8 8 7 5 3 6 5 4 7 3 4 6 7 8 1 3 2 7 42 2 6 3 5 3 4 9 2 4 5 7 6 6 3 2 7 2 4 8 5 5 47 4 4 5 8 3 3 8 1 8 6 3 2 1 6 2 6 4 6 3 8 2 9 61 2 4 1 3 3 5 3 4 9 6 3 8 6 5 9 1 5 3 2 6 8 8 5 32 2 7 9 3 3 2 8 6 9 8 4 4 9 5 8 2 6 3 4 8 4 9 3 8 87 7 7 9 7 5 2 7 9 2 5 1 9 2 6 5 3 9 3 5 7 3 5 4 2 8 97 7 6 6 8 7 5 5 8 2 4 7 7 4 7 2 6 9 2 1 8 2 9 8 5 7 3 65 9 4 5 5 7 5 5 6 3 5 3 9 5 8 9 5 4 1 2 6 1 4 3 5 3 2 4 1*/
public class q3承压计算 {//1、怎么接收上面的数字 》》》二维数组!!//2、自上而下处理a[i][j]*factor (2的30次方）===》除以二 计入a[i+1][j] 和a[i+!][j+1]//循环处理2-N-1行//对a[n-1]这一行进行排序，查看最小值于factor之间的倍数关系，决定最大值是多少static long[][]a=new long[30][30];//long int放不下public static void main(String[] args) {Scanner sc=new Scanner(System.in);long factor=1;//2的30次方for (int i = 0; i < 30; ++i) {factor<<=1;//!!amazing左移？右移 1073741824 ==factor*2}for (int i=0;i<29;i++){//只有29行for (int j=0;j<=i;j++){//(int j=0;j<28;j++)不对,j<=i为什么!?a[i][j]=sc.nextLong()*factor;
// a[i][j]=sc.nextLong();}}//第二步for(int i=0;i<29;i++){//元数据只有29行for (int j=0;j<=i;j++){long temp = a[i][j] / 2;a[i+1][j]+=temp;a[i+1][j+1]+=temp;}}
// for (long[] longs : a) {// for (long aLong : longs) {// System.out.print(aLong+" ");
// }
// System.out.println();
// }/*
7 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
5 8 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
7 8 8 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
9 2 7 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
8 1 4 9 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
8 1 8 8 4 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
7 9 6 1 4 5 4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
5 6 5 5 6 9 5 6 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
5 5 4 7 9 3 5 5 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
7 5 7 9 7 4 7 3 3 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
4 6 4 5 5 8 8 3 2 4 3 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
1 1 3 3 1 6 6 5 5 4 4 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
9 9 9 2 1 9 1 9 2 9 5 7 9 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
4 3 3 7 7 9 3 6 1 3 8 8 3 7 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
3 6 8 1 5 3 9 5 8 3 8 1 8 3 3 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
8 3 2 3 3 5 5 8 5 4 2 8 6 7 6 9 0 0 0 0 0 0 0 0 0 0 0 0 0 0
8 1 8 1 8 4 6 2 2 1 7 9 4 2 3 3 4 0 0 0 0 0 0 0 0 0 0 0 0 0
2 8 4 2 2 9 9 2 8 3 4 9 6 3 9 4 6 9 0 0 0 0 0 0 0 0 0 0 0 0
7 9 7 4 9 7 6 6 2 8 9 4 1 8 1 7 2 1 6 0 0 0 0 0 0 0 0 0 0 0
9 2 8 6 4 2 7 9 5 4 1 2 5 1 7 3 9 8 3 3 0 0 0 0 0 0 0 0 0 0
5 2 1 6 7 9 3 2 8 9 5 5 6 6 6 2 1 8 7 9 9 0 0 0 0 0 0 0 0 0
6 7 1 8 8 7 5 3 6 5 4 7 3 4 6 7 8 1 3 2 7 4 0 0 0 0 0 0 0 0
2 2 6 3 5 3 4 9 2 4 5 7 6 6 3 2 7 2 4 8 5 5 4 0 0 0 0 0 0 0
7 4 4 5 8 3 3 8 1 8 6 3 2 1 6 2 6 4 6 3 8 2 9 6 0 0 0 0 0 0
1 2 4 1 3 3 5 3 4 9 6 3 8 6 5 9 1 5 3 2 6 8 8 5 3 0 0 0 0 0
2 2 7 9 3 3 2 8 6 9 8 4 4 9 5 8 2 6 3 4 8 4 9 3 8 8 0 0 0 0
7 7 7 9 7 5 2 7 9 2 5 1 9 2 6 5 3 9 3 5 7 3 5 4 2 8 9 0 0 0
7 7 6 6 8 7 5 5 8 2 4 7 7 4 7 2 6 9 2 1 8 2 9 8 5 7 3 6 0 0
5 9 4 5 5 7 5 5 6 3 5 3 9 5 8 9 5 4 1 2 6 1 4 3 5 3 2 4 1 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0*///对30行的数据进行排序,查看最小值于factor之间的关系,决定最大值是多少System.out.println(factor);Arrays.sort(a[29]);System.out.println(a[29][0]/2086458231);System.out.println(a[29][29]);System.out.println(a[29][29]/(a[29][0]/2086458231));}
}
四、魔方状态
标题：魔方状态
二阶魔方就是只有2层的魔方，只由8个小块组成。
如图p1.png所示。
小明很淘气，他只喜欢3种颜色，所有把家里的二阶魔方重新涂了颜色，如下：
前面：橙色
右面：绿色
上面：黄色
左面：绿色
下面：橙色
后面：黄色
请你计算一下，这样的魔方被打乱后，一共有多少种不同的状态。
如果两个状态经过魔方的整体旋转后，各个面的颜色都一致，则认为是同一状态。
请提交表示状态数的整数，不要填写任何多余内容或说明文字。
bfs宽搜
模拟+去重+状态转移！
魔方的状态怎么保存？
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tbkKskxU-1651583658468)(蓝桥杯真题2017-2021Img/image-20220403111715555.png)]
这题有点恶心,把8个块记录为一个数组，每个块有6个面，所以块也是个数组，所以开个二维数组模拟，每次操作有3种，向前顺时针,向上顺时针 ,向左顺时针,hhha，看的有点迷惑了把，不知道大家有没发现玩魔方的大佬玩魔方的时候，只对一个角只往3个方向旋转呢，没错，我们就用bfs记录下所有的状态，大概的思路是这样的= =
import java.util.HashSet;
import java.util.Set;/*
标题：魔方状态
二阶魔方就是只有2层的魔方，只由8个小块组成。
如图p1.png所示。
小明很淘气，他只喜欢3种颜色，所有把家里的二阶魔方重新涂了颜色，如下：
前面：橙色
右面：绿色
上面：黄色
左面：绿色
下面：橙色
后面：黄色
请你计算一下，这样的魔方被打乱后，一共有多少种不同的状态。
如果两个状态经过魔方的整体旋转后，各个面的颜色都一致，则认为是同一状态。
请提交表示状态数的整数，不要填写任何多余内容或说明文字。
*/
public class _03魔方状态 {static char[][] start = {"oybbgb".toCharArray(),"oygbbb".toCharArray(),"bygbby".toCharArray(),"bybbgy".toCharArray(),"obbogb".toCharArray(),"obgobb".toCharArray(),"bbgoby".toCharArray(),"bbbogy".toCharArray()};static char[][][] q = new char[2000000][8][6];static Set<String> all_state = new HashSet<String>();static int front, tail;static String to_string(char[][] a) {String ans = "";for (int i = 0; i < 8; ++i) {ans += new String(a[i]);}return ans;}private static void swap(char[] a, int i, int j) {char t = a[i];a[i] = a[j];a[j] = t;}private static void swap(char[][] a, int i, int j) {char[] t = a[i];a[i] = a[j];a[j] = t;}//上层的块的旋转，面的相对位置调换static void ucell(char[] a) {swap(a, 0, 2);swap(a, 2, 5);swap(a, 5, 4);}//上层顺时针旋转static void u(char[][] s) {ucell(s[0]);ucell(s[1]);ucell(s[2]);ucell(s[3]);
// 块的相对位置调换swap(s, 1, 0);swap(s, 2, 1);swap(s, 3, 2);}//右层旋转是面的位置变化static void rcell(char[] a) {swap(a, 1, 0);swap(a, 0, 3);swap(a, 3, 5);}static void r(char[][] s)//魔方右层顺时针转{rcell(s[1]);rcell(s[2]);rcell(s[6]);rcell(s[5]);
// 块的位置变化swap(s, 2, 1);swap(s, 5, 1);swap(s, 6, 5);}static void fcell(char[] a) {swap(a, 2, 1);swap(a, 1, 4);swap(a, 4, 3);}static void f(char[][] s)//前面一层 顺时针转{fcell(s[0]);fcell(s[1]);fcell(s[4]);fcell(s[5]);swap(s, 1, 5);swap(s, 0, 1);swap(s, 4, 0);}static void uwhole(char[][] s)//整个魔方从顶部看 顺时针转 用于判重{u(s);//上层旋转
// 下层旋转ucell(s[4]);ucell(s[5]);ucell(s[6]);ucell(s[7]);
// 完成自旋后，块的位置变动swap(s, 5, 4);swap(s, 6, 5);swap(s, 7, 6);}static void fwhole(char[][] s)//整个魔方从前面看 顺时针转 用于判重{f(s);fcell(s[2]);fcell(s[6]);fcell(s[7]);fcell(s[3]);swap(s, 2, 6);swap(s, 3, 2);swap(s, 7, 3);}static void rwhole(char[][] s)//整个魔方从右边看 顺时针转 用于判重{r(s);rcell(s[0]);rcell(s[3]);rcell(s[4]);rcell(s[7]);swap(s, 3, 7);swap(s, 0, 3);swap(s, 4, 0);}static boolean try_insert(char[][] s) {char[][] k = new char[8][6];memcpy(k, s);for (int i = 0; i < 4; i++) {fwhole(k);for (int j = 0; j < 4; j++) {uwhole(k);for (int q = 0; q < 4; q++) {rwhole(k);if (all_state.contains(to_string(k))) {return false;}}}}all_state.add(to_string(k));return true;}private static void memcpy(char[][] k, char[][] s) {for (int i = 0; i < 8; i++) {for (int j = 0; j < 6; j++) {k[i][j] = s[i][j];}}}static void solve() {front = 0;tail = 1;all_state.add(to_string(start));memcpy(q[front], start);//填充q[0]，相当于第一个状态入队列while (front < tail) {/*将其所有变形，尝试加入set中*/memcpy(q[tail], q[front]);//拷贝到tailu(q[tail]);//上层顺时针旋转if (try_insert(q[tail])) {tail++;//扩展队列}memcpy(q[tail], q[front]);//拷贝到tailr(q[tail]);//右层顺时针旋转if (try_insert(q[tail])) {tail++;//扩展队列}memcpy(q[tail], q[front]);//拷贝到tailf(q[tail]);//前顺时针旋转if (try_insert(q[tail])) {tail++;//扩展队列}front++;//弹出队首
// cout << front << " " << tail << endl;}System.out.println(front);}public static void main(String[] args) {solve();}
}
五、取数位
标题：取数位求1个整数的第k位数字有很多种方法。
以下的方法就是一种。public class Main
{undefinedstatic int len(int x){undefinedif(x<10) return 1;return len(x/10)+1;}// 取x的第k位数字static int f(int x, int k){undefinedif(len(x)-k==0) return x%10;return ______________________; //填空}public static void main(String[] args){undefinedint x = 23513;//System.out.println(len(x));System.out.println(f(x,3));}
}对于题目中的测试数据，应该打印5。请仔细分析源码，并补充划线部分所缺少的代码。注意：只提交缺失的代码，不要填写任何已有内容或说明性的文字。
return f(x/10,k);
package q2017;public class q5 {public static class Main{static int len(int x){if(x<10) return 1;return len(x/10)+1;}// 取x的第k位数字static int f(int x, int k){//递归嘛,查看参数的含义不是k增大,就是x减少,但是k应该不会变,k是位数,x减少,x向上取,去掉最末一位,进行递归,知道长度满足k,得到结果if(len(x)-k==0) return x%10;//求最末一位return f(x/10,k);//不是求最末一位}public static void main(String[] args){int x = 23513;//System.out.println(len(x));System.out.println(f(x,3));}}
}
六、最大公共子串
标题：最大公共子串最大公共子串长度问题就是：
求两个串的所有子串中能够匹配上的最大长度是多少。比如："abcdkkk" 和 "baabcdadabc"，
可以找到的最长的公共子串是"abcd",所以最大公共子串长度为4。下面的程序是采用矩阵法进行求解的，这对串的规模不大的情况还是比较有效的解法。请分析该解法的思路，并补全划线部分缺失的代码。public class Main
{undefinedstatic int f(String s1, String s2){undefinedchar[] c1 = s1.toCharArray();char[] c2 = s2.toCharArray();int[][] a = new int[c1.length+1][c2.length+1];int max = 0;for(int i=1; i<a.length; i++){undefinedfor(int j=1; j<a[i].length; j++){undefinedif(c1[i-1]==c2[j-1]) {a[i][j] = __________________; //填空 if(a[i][j] > max) max = a[i][j];}}}return max;}public static void main(String[] args){undefinedint n = f("abcdkkk", "baabcdadabc");System.out.println(n);}
}注意：只提交缺少的代码，不要提交已有的代码和符号。也不要提交说明性文字。
a[i][j] = a[i-1][j-1]+1 ; //填空
字串是连续的，不是序列
这是个动态规划
那么什么是动态规划呢？我们以后再说
历史上的格子生成新的格子
最长公共子序列
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kaAc0AzS-1651583658469)(蓝桥杯真题2017-2021Img/image-20220403153812592.png)]
package q2017;public class q6最大公共子串 {static class Main {static int f(String s1, String s2)//输入两个字符串{char[] c1 = s1.toCharArray();//将字符串转化为字符数组char[] c2 = s2.toCharArray();//新建一个二维字符数组int[][] a = new int[c1.length+1][c2.length+1];//max?最大公共串长度?int max = 0;for(int i=1; i<a.length; i++){ //将c1的每一个字符和c2的每一个字符一一进行比对for(int j=1; j<a[i].length; j++){if(c1[i-1]==c2[j-1]) {//两个字符如果相等,则a[i][j] = a[i-1][j-1]+1 ; //填空if(a[i][j] > max) max = a[i][j];}}}return max;}public static void main(String[] args){int n = f("abcdkkk", "baabcdadabc");System.out.println(n);}}
}
七、日期问题
标题：日期问题小明正在整理一批历史文献。这些历史文献中出现了很多日期。小明知道这些日期都在1960年1月1日至2059年12月31日。令小明头疼的是，这些日期采用的格式非常不统一，有采用年/月/日的，有采用月/日/年的，还有采用日/月/年的。更加麻烦的是，年份也都省略了前两位，使得文献上的一个日期，存在很多可能的日期与其对应。比如02/03/04，可能是2002年03月04日、2004年02月03日或2004年03月02日。给出一个文献上的日期，你能帮助小明判断有哪些可能的日期对其对应吗？输入
----
一个日期，格式是"AA/BB/CC"。 (0 <= A, B, C <= 9) 输入
----
输出若干个不相同的日期，每个日期一行，格式是"yyyy-MM-dd"。多个日期按从早到晚排列。 样例输入
----
02/03/04 样例输出
----
2002-03-04
2004-02-03
2004-03-02 资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是：Main，否则按无效代码处理。
要日期校验、排序去重
package q2017;import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;public class q7日期问题s1 {//计算是否是闰年static boolean isLeap(int year) { // 闰年：2月29天；平年：2月28天return (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;//能够被400整除或者是4的倍数但是不能被100整除}//模拟基本逻辑操作,以年月日为模板,这样只要修改abc的传入顺序即可static String f(int a, int b, int c) {//日期大小检验if (a >= 0 && a <= 59)a += 2000;else if (a >= 60 && a <= 99)a += 1900;elsereturn "";if (b < 1 || b > 12)return "";if (c < 1 || c > 31)return "";
//闰年检测boolean _isLeap = isLeap(a);switch (b) { // 日期校验case 2:if (_isLeap && c > 29)return "";if (!_isLeap && c > 28)return "";break;case 4:if (c > 30)return "";break;case 6:if (c > 30)return "";break;case 9:if (c > 30)return "";break;case 11:if (c > 30)return "";break;/*case 4:case 6:case 9:case 11:if (c > 30)return "";break;可以合起来一起写
*/default:break;}//将数字转换为字符串String _a = a + "", _b = b + "", _c = c + "";//补0if (_b.length() == 1)_b = "0" + _b;if (_c.length() == 1)_c = "0" + _c;//打印return _a + "-" + _b + "-" + _c;}public static void main(String[] args) {Scanner sc = new Scanner(System.in);String in = sc.nextLine();int a = 0, b = 0, c = 0;//charAt获取字符,然后减去'0'就变成了int类型/*02/03/04a=0*10+2b=0*10+3c=0*10+4*/a = (in.charAt(0) - '0') * 10 + (in.charAt(1) - '0');b = (in.charAt(3) - '0') * 10 + (in.charAt(4) - '0');c = (in.charAt(6) - '0') * 10 + (in.charAt(7) - '0');String case1 = f(a, b, c);//分别计算a是年,b是月,c是日String case2 = f(c, a, b);//分别计算c是年,a是月,b是日String case3 = f(c, b, a);//分别计算c是年,b是月,a是日Set<String> ans = new TreeSet<String>(); // TreeSet带去重和排序功能if (case1 != "")ans.add(case1);if (case2 != "")ans.add(case2);if (case3 != "")ans.add(case3);for (String s : ans) {System.out.println(s);}}
}
八、包子凑数
标题：包子凑数
小明几乎每天早晨都会在一家包子铺吃早餐。他发现这家包子铺有N种蒸笼，其中第i种蒸笼恰好能放Ai个包子。每种蒸笼都有非常多笼，可以认为是无限笼。
每当有顾客想买X个包子，卖包子的大叔就会迅速选出若干笼包子来，使得这若干笼中恰好一共有X个包子。比如一共有3种蒸笼，分别能放3、4和5个包子。当顾客想买11个包子时，大叔就会选2笼3个的再加1笼5个的（也可能选出1笼3个的再加2笼4个的）。
当然有时包子大叔无论如何也凑不出顾客想买的数量。比如一共有3种蒸笼，分别能放4、5和6个包子。而顾客想买7个包子时，大叔就凑不出来了。
小明想知道一共有多少种数目是包子大叔凑不出来的。
第一行包含一个整数N。(1 <= N <= 100)
以下N行每行包含一个整数Ai。(1 <= Ai <= 100)
一个整数代表答案。如果凑不出的数目有无限多个，输出INF。
例如，
输入：
2
4
5程序 应该输出：
6再例如，
输入：
2
4
6程序应该输出：
INF样例解释：
对于样例1，凑不出的数目包括：1, 2, 3, 6, 7, 11。
对于样例2，所有奇数都凑不出来，所以有无限多个。资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是：Main，否则按无效代码处理。
提交程序时，注意选择所期望的语言类型和编译器类型。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JTRPA23e-1651583658469)(蓝桥杯真题2017-2021Img/image-20220403163143433.png)]
package q2017;import java.util.Scanner;public class q8包子凑数s1 {//完全背包+gcd求最大公约数public static int gcd(int a, int b){if (b==0)return a;return gcd(b,a%b);}//完全背包static boolean [] f=new boolean[10000];//最大公约数static int g;public static void main(String[] args) {Scanner sc=new Scanner(System.in);int n=sc.nextInt();//第一个数一定可以凑数来 f[0]是0,可以一个都不选即可f[0]=true;int[] a =new int[n+5];for (int i=1;i<=n;i++){//为什么i==1?a[i]=sc.nextInt();//求最大公约数if (i==1){g=a[i];}else {g=gcd(g,a[i]);}//完全背包的递推for(int j=0;j<10000-a[i];j++){if (f[j]){f[j+a[i]]=true;}}}
if (g!=1){System.out.println("INF");return;//必须要不然不会停止
}
int ans=0;//统计个数for (int i=0;i<10000;i++){if (!f[i]){ans++;}}System.out.println(ans);}
}
九、分巧克力
标题： 分巧克力儿童节那天有K位小朋友到小明家做客。小明拿出了珍藏的巧克力招待小朋友们。小明一共有N块巧克力，其中第i块是Hi x Wi的方格组成的长方形。为了公平起见，小明需要从这 N 块巧克力中切出K块巧克力分给小朋友们。切出的巧克力需要满足：1. 形状是正方形，边长是整数 2. 大小相同 例如一块6x5的巧克力可以切出6块2x2的巧克力或者2块3x3的巧克力。当然小朋友们都希望得到的巧克力尽可能大，你能帮小Hi计算出最大的边长是多少么？输入
第一行包含两个整数N和K。(1 <= N, K <= 100000)
以下N行每行包含两个整数Hi和Wi。(1 <= Hi, Wi <= 100000)
输入保证每位小朋友至少能获得一块1x1的巧克力。 输出
输出切出的正方形巧克力最大可能的边长。样例输入：
2 10
6 5
5 6 样例输出：
2资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是：Main，否则按无效代码处理。
没有!!!历史的做法延续到下一步
package q2017;import java.util.Scanner;public class q9分巧克力 {public static void main(String[] args) {Scanner sc=new Scanner(System.in);int N,K;N=sc.nextInt();//N块巧克力K=sc.nextInt();//k个人int [] w=new int[N];int []h =new int[N];for(int i=0;i<N;i++){h[i]=sc.nextInt();w[i]=sc.nextInt();}//二分法查找int r=100001;int l=1;int ans=0;//答案个数while (l<=r){int mid=(l+r)/2;int cnt=0;//每个巧克力块都按len切割for (int i = 0; i < N; i++) {cnt+=(h[i]/mid)*(w[i]/mid);}if (cnt>=K){l=mid+1;ans=mid;}else {r=mid-1;}}System.out.println(ans);}}
十、k倍区间
标题： k倍区间给定一个长度为N的数列，A1, A2, ... AN，如果其中一段连续的子序列Ai, Ai+1, ... Aj(i <= j)之和是K的倍数，我们就称这个区间[i, j]是K倍区间。 你能求出数列中总共有多少个K倍区间吗？ 输入
-----
第一行包含两个整数N和K。(1 <= N, K <= 100000)
以下N行每行包含一个整数Ai。(1 <= Ai <= 100000) 输出
-----
输出一个整数，代表K倍区间的数目。 例如，
输入：
5 2
1
2
3
4
5 程序应该输出：
6资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 2000ms请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是：Main，否则按无效代码处理。方法1暴力
枚举i,j,算出所有可能的结果
暴力优化
对于静态数据可以使用前缀(树状array\区间树)
package q2017;import java.util.Scanner;public class q10k倍区间 {public static void main(String[] args) {Scanner sc=new Scanner(System.in);int n=sc.nextInt();//数列长度int k=sc.nextInt();//k值
// int[] a=new int[n];int []sum=new int[n+1];//前缀和for (int i = 1; i <=n ; i++) {// a[i]=sc.nextInt();sum[i]=sum[i-1]+sc.nextInt();}int ans=0;for (int i=1;i<=n;i++){for (int j = 0; j +i <= n; j++) {//枚举i,j
// i,j之间的区间和s[j]-s[i-1]if ((sum[j+i]-sum[j])%k==0){ans++;}}}System.out.println(ans);}
}
小结
01 购物单 简单计算 excel
02 纸牌三角形 全排列+特殊去重
*03 承压计算 数组 注意计量单位，要精确就先放大2^30来做除法
**04 魔方状态 模拟+去重
05 取数位 递归 搞清楚参数的含义及参数变化的方向
06 最大公共子串 经典dp
07 日期问题 常规日期运算，细心，考虑闰年；字符串处理
***08 包子凑数 扩展欧几里得 + 完全背包问题（dp）
09 分巧克力 二分枚举
****10 k倍区间 前缀和+组合数学
小结
01 购物单 简单计算 excel
02 纸牌三角形 全排列+特殊去重
*03 承压计算 数组 注意计量单位，要精确就先放大2^30来做除法
**04 魔方状态 模拟+去重
05 取数位 递归 搞清楚参数的含义及参数变化的方向
06 最大公共子串 经典dp
07 日期问题 常规日期运算，细心，考虑闰年；字符串处理
***08 包子凑数 扩展欧几里得 + 完全背包问题（dp）
09 分巧克力 二分枚举
****10 k倍区间 前缀和+组合数学
2018年真题
一、第几天
标题：第几天
2000年的1月1日，是那一年的第1天。
那么，2000年的5月4日，是那一年的第几天？
注意：需要提交的是一个整数，不要填写任何多余内容。
简单直接算即可31+29+31+30+4=125二、方格计数
标题：方格计数
如图p1.png所示，在二维平面上有无数个1x1的小方格。
我们以某个小方格的一个顶点为圆心画一个半径为1000的圆。
你能计算出这个圆里有多少个完整的小方格吗？
注意：需要提交的是一个整数，不要填写任何多余内容。
package provincialGames_09_2018;public class A02_方格计数 {public static void main(String[] args) {// lwx解法int count = 0;for (int x = 0; x <= 1000; x++) {for (int y = 0; y <= 1000; y++) {if ((x + 1) * (x + 1) + (y + 1) * (y + 1) <= 1000 * 1000) {count++;}}}System.out.println(count * 4);// 郑未老师 解法1int r = 0;for (int i = -1000; i <= 1000; i++) {for (int j = -1000; j <= 1000; j++) {if (i * i + j * j <= 1000 * 1000) {if (i == 0 || j == 0) // 点不能在轴上continue;r++;}}}System.out.println(r);// 郑未老师 解法2【稍微优化一点的解法】int N = 1000;int y = N;int ans = 0;for (int x = 1; x <= N; x++) { //扫描每一行while (x * x + y * y > N * N && y > 0) {y--;}ans += y;}System.out.println(ans * 4);}
}
三、复数幂
标题：复数幂
设i为虚数单位。对于任意正整数n，(2+3i)^n 的实部和虚部都是整数。
求 (2+3i)^123456 等于多少？ 即(2+3i)的123456次幂，这个数字很大，要求精确表示。
答案写成 “实部±虚部i” 的形式，实部和虚部都是整数（不能用科学计数法表示），中间任何地方都不加空格，实部为正时前面不加正号。(2+3i)^2 写成: -5+12i，
(2+3i)^5 的写成: 122-597i
package q2018;import java.io.FileOutputStream;
import java.io.PrintStream;
import java.math.BigInteger;public class q3复数幂 {/*复苏计算公式(a+bi)x(c+di)=(ac-bd)+(bc+ad)i(2+3i）^123456次方很大，控制台输出不全，只能显示一部分，所以只能保存到文件中，——>>>javaIO判断b的正负，选择要不要+号*/static void IOTest(){try {PrintStream ps = new PrintStream(new FileOutputStream("text.txt"));System.setOut(ps);System.out.println("普通字符串");System.out.println(new q3复数幂());}catch (Exception e){e.printStackTrace();}}public static void main(String[] args) {// IOTest();//try {//改变输出流到work.txt文件PrintStream ps = new PrintStream(new FileOutputStream("q3.txt"));System.setOut(ps);//文件输出，用system.out.println()即可将内容输出到文件BigInteger a = new BigInteger("2");BigInteger b = new BigInteger("3");BigInteger x = new BigInteger("2");//作为以后累计的值BigInteger y = new BigInteger("3");int cnt=0;for(int i=0;i<123455;i++){//0相当于2次幂，123454相当于123456BigInteger t=x;//存放原来的xx=x.multiply(a).subtract(y.multiply(b));y=t.multiply(b).add(y.multiply(a));cnt++;}System.out.println(x+""+((y.compareTo(BigInteger.ZERO)>0)?"+":"")+y+"i");System.out.println(cnt);}catch (Exception e){//抛出异常e.printStackTrace();}}
}
四、测试次数
package q2018;import javafx.scene.transform.Scale;import javax.script.SimpleScriptContext;
import java.util.*;public class q8日志统计 {/*标题：日志统计
小明维护着一个程序员论坛。现在他收集了一份"点赞"日志，日志共有N行。其中每一行的格式是：
ts id
表示在ts时刻编号id的帖子收到一个"赞"。
现在小明想统计有哪些帖子曾经是"热帖"。如果一个帖子曾在任意一个长度为D的时间段内收到不少于K个赞，小明就认为这个帖子曾是"热帖"。
具体来说，如果存在某个时刻T满足该帖在[T, T+D)这段时间内(注意是左闭右开区间)收到不少于K个赞，该帖就曾是"热帖"。
给定日志，请你帮助小明统计出所有曾是"热帖"的帖子编号。
【输入格式】
第一行包含三个整数N、D和K。
以下N行每行一条日志，包含两个整数ts和id。
对于50%的数据，1 <= K <= N <= 1000
对于100%的数据，1 <= K <= N <= 100000 0 <= ts <= 100000 0 <= id <= 100000
【输出格式】
按从小到大的顺序输出热帖id。每个id一行。
【输入样例】
7 10 2
0 1
0 10
10 10
10 1
9 1
100 3
100 3
【输出样例】
1
3
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms题目分析：重点排序+去重，然后根据排完序的结果使用遍历双指针遍历即可*/static class R{// 存日志数据, ts-td分别是时刻及id,组合成对象, 存储在R中int ts,id;//时刻及id}public static void main(String[] args) {Scanner sc=new Scanner(System.in);int N= sc.nextInt();//N行日志int D=sc.nextInt();//时间间隔int K=sc.nextInt();//满足k个赞//1.接受数据R[] rs = new R[N];for (int i = 0; i < N; i++) {R r = new R();r.ts=sc.nextInt();r.id=sc.nextInt();rs[i]=r;}//2.匿名内部类 定义，排序器，自定义 比较器Arrays.sort(rs, new Comparator<R>() {@Overridepublic int compare(R o1, R o2) {return o1.ts-o2.ts;}});//cnt:用于给id记数，记录id及其出现的次数Map<Integer,Integer> cnt=new HashMap<>();//用于存储答案（各id），因为答案要求输出有序，这里直接用TreeSetSortedSet<Integer> ans=new TreeSet<>();//3.尺取法int j=0;//移动哨兵？尾指针--用于探测for (int i = 0; i < N; i++) {//头指针//循环条件：i,j之间间隔不超过D，且j不越界while (j<N&&rs[j].ts-rs[i].ts<D){int id=rs[j].id;Integer exist = cnt.get(id);//查找map种是否存在这个id，存在则返回个数if (exist!=null){//不会空，说明之前有遇到过，个数+1cnt.put(id,exist+1);}else {cnt.put(id,1);//id第一次出现}if (cnt.get(id)>=K){//到了这一行，检测是否满足其出现次数>=k，满足则加将id插入到ans中ans.add(id);}j++;}// 头指针即将往下移动，所以我们要删除原来cnt里面的id数Integer cntOfI = cnt.get(rs[i].id);// 上一个区间, td的计数要扣除, 不干扰下一个区间的统计if (cntOfI!=null){cnt.put(rs[i].id,cntOfI-1);}}for (Integer an : ans) {System.out.println(an);}}
}
九、全球变暖
标题：全球变暖
你有一张某海域NxN像素的照片，".“表示海洋、”#"表示陆地，如下所示：
…
.##…
.##…
…##.
…####.
…###.
…
其中"上下左右"四个方向上连在一起的一片陆地组成一座岛屿。例如上图就有2座岛屿。
由于全球变暖导致了海面上升，科学家预测未来几十年，岛屿边缘一个像素的范围会被海水淹没。具体来说如果一块陆地像素与海洋相邻(上下左右四个相邻像素中有海洋)，它就会被淹没。
例如上图中的海域未来会变成如下样子：
…
…
…
…
…#…
…
…
请你计算：依照科学家的预测，照片中有多少岛屿会被完全淹没。
【输入格式】
第一行包含一个整数N。 (1 <= N <= 1000)
以下N行N列代表一张海域照片。
照片保证第1行、第1列、第N行、第N列的像素都是海洋。
【输出格式】
一个整数表示答案。
【输入样例】
7
…
.##…
.##…
…##.
…####.
…###.
…
【输出样例】
1
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是：Main，否则按无效代码处理。
题解
连通块问题+计数 N ≤ 10^3 N*N ≤ 10^6a：陆地(块)的个数；b：与水相邻的陆地数量。== 》 a ==b，ans++深搜dfs：递归深度过深，栈内存不足。
宽搜bfs：O(n)最多为10^6，非递归。
对象 + 队列
Object + Queue
自定义对象 用队列维护 由一个点，向四周扩散。
package q2018;import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;public class q9全球变暖 {/*宽度搜索+优先搜索：先讲讲我现在的理解程度从第一个格子开始遍历，宽度优先，使用队列，如果方向岛屿？，统计#陆地的数量和被海洋淹没的陆地的数量，如果这两在这个岛屿中相等，说明这个岛屿被淹没了即ans++*/static int[] dx = {-1, 1, 0, 0};//x可能走的四个方向，其实就是向左或者向右把？static int[] dy = {0, 0, -1, 1};//x可能走的四个方向，其实就是向左或者向右把？private static int n;//代表n行数据static char[][] g;//grap地图数据static int[][] mark;//标记数组，标记每个格子是被访问static int ans = 0;//结果，被淹没的岛屿数//1.自定义类static class Point {int x, y;public Point(int x, int y) {this.x = x;this.y = y;}}public static void main(String[] args) {//2.接收参数Scanner sc = new Scanner(System.in);n = sc.nextInt();//接受的行数//初始化g和mark,不然报错g = new char[n][n];mark = new int[n][n];
// !!!!读换行符sc.nextLine();for (int i = 0; i < n; i++) {g[i] = sc.nextLine().toCharArray();//将行转化为字符数组}//3.双重循环检验# . ，开始bfs//检验地图上的每个格子，以未被访问的#为起点开始深度搜索for (int i = 0; i < n; i++) {for (int j = 0; j < n; j++) {if (g[i][j] == '#' && mark[i][j] == 0) {bfs(i, j);//从这个点开始深度搜索，做标记访问过的格子不访问}}}System.out.println(ans);}//4、bfsprivate static void bfs(int i, int j) {//首先进入了bfs就要做标记mark[i][j] = 1;//关键int cntOfBlock = 0;//记录#陆地的数量int cntOfSwe = 0;//记录和.相邻的#的数量，被淹没陆地的数量！//新建队列，作用bfs存放点Queue<Point> queue = new LinkedList<>();queue.add(new Point(i, j));while (!queue.isEmpty()) {Point first = queue.poll();//弹出第一个cntOfBlock++;//陆地增加//------------------------------------------------------------------------------------boolean swed = false;//标记弹出的#四周是否有.//探测for (int d = 0; d < 4; d++) {int nx = first.x + dx[d];//int ny = first.y + dy[d];//if (nx >= 0 && nx < n && ny >= 0 && ny < n) {if (g[nx][ny] == '.') {swed = true;// 周边有一个.这块陆地就会被淹没，避免重复计数}if (g[nx][ny] == '#' && mark[nx][ny] == 0) { // 且‘#’没有被访问queue.add(new Point(nx, ny));mark[nx][ny] = 1;}}}if (swed) {//一个连通块被访问完了，块中#的数量记录在cnt1，周边有。的#的数量在cnt2cntOfSwe++;}}if (cntOfBlock == cntOfSwe) {ans++;// 陆地数量 与 被淹没陆地数量 相同,ans++}}
}
十、堆的计数
标题：堆的计数我们知道包含N个元素的堆可以看成是一棵包含N个节点的完全二叉树。
每个节点有一个权值。对于小根堆来说，父节点的权值一定小于其子节点的权值。 假设N个节点的权值分别是1~N，你能求出一共有多少种不同的小根堆吗？ 例如对于N=4有如下3种：1/ \2 3/
41/ \3 2/
41/ \2 4/
3由于数量可能超过整型范围，你只需要输出结果除以1000000009的余数。 【输入格式】
一个整数N。
对于40%的数据，1 <= N <= 1000
对于70%的数据，1 <= N <= 10000
对于100%的数据，1 <= N <= 100000【输出格式】
一个整数表示答案。 【输入样例】
4 【输出样例】
3资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是：Main，否则按无效代码处理。
小样本暴力可以
package q2018;import java.util.Scanner;public class q10堆的记数 {// 解题思路：全排列+筛选static int[] a;static int ans=0;public static void main(String[] args) {Scanner sc = new Scanner(System.in);int n = sc.nextInt();//输入的节点数a = new int[n];for (int i = 0; i < n; i++) {a[i] = i + 1;}dfs(0);System.out.println(ans);}static void dfs(int k) {if (k == a.length) {if (check()){ans++;}
// return;}for (int i = k; i < a.length; i++) {int t = a[i];a[i] = a[k];a[k] = t;dfs(k + 1);t = a[i];a[i] = a[k];a[k] = t;}}static boolean check() {//我们要的是小根堆，即父节点的权重一定小于子节点的权重boolean flag = false;for (int i = 0; i < a.length; i++) {//约束条件if ((i * 2 + 1) < a.length && (i * 2 + 2) < a.length && a[i] < a[i * 2 + 1]&& a[i] < a[i * 2 + 2]) {flag = true;} else if ((i * 2 + 1) < a.length && (i * 2 + 2) >= a.length && a[i] < a[i * 2 + 1]) {flag = true;} else if ((i * 2 + 1) >= a.length) {flag = true;} else {flag = false;return false;}}
return flag;}
}
不知道什么方法解的
package q2018;import java.util.Scanner;public class q10s1 {static final int MOD = 1000000009;public static int N;static int[] size; // 记录每个节点的sizestatic long[] jie; // 记录1~N的阶乘static long[] ni; // 记录1~N的阶乘的逆元（关于MOD）public static void main(String[] args) {Scanner sc = new Scanner(System.in);N = sc.nextInt();size = new int[N + 1];jie = new long[N + 1];ni = new long[N + 1];initSize();initJie();System.out.println(dp());}private static long dp() {long[] d = new long[N + 1]; // d[i]表示的是i号节点作为根，小根堆的种数for (int x = N; x >= 1; x--) {if (2 * x + 1 <= N)d[x] = c(size[x] - 1, size[2 * x]) * d[2 * x] % MOD * d[2 * x + 1] % MOD;else if (2 * x <= N)d[x] = c(size[x] - 1, size[2 * x]) * d[2 * x] % MOD;elsed[x] = 1;}return d[1];}private static void initJie() {jie[0] = 1;ni[0] = 1;for (int i = 1; i <= N; i++) {jie[i] = jie[i - 1] * i % MOD;ni[i] = pow(jie[i], MOD - 2);}}/*** 快速求a的n次方** @param a* @param n* @return*/private static long pow(long a, int n) {if (a == 0)return 0;long ans = 1;long x = a;while (n > 0) {if ((n & 1) == 1)ans = ans * x % MOD;n >>= 1;x = x * x % MOD;}return ans;}static long c(int n, int r) {return jie[n] * ni[r] % MOD * ni[n - r] % MOD;}private static void initSize() {for (int i = N; i >= 1; i--) {size[i] = (2 * i <= N ? size[2 * i] : 0) + (2 * i + 1 <= N ? size[2 * i + 1] : 0) + 1;}}
}
2019年真题
01-试题 A: 组队
本题总分：5 分
【问题描述】
作为篮球队教练，你需要从以下名单中选出 1 号位至 5 号位各一名球员，组成球队的首发阵容。
每位球员担任 1 号位至 5 号位时的评分如下表所示。请你计算首发阵容 1 号位至 5 号位的评分之和最大可能是多少？
（如果你把以上文字复制到文本文件中，请务必检查复制的内容是否与文档中的一致。在试题目录下有一个文件 team.txt，内容与上面表格中的相同，请注意第一列是编号）
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
我觉得就是暴力,只不过要注意约束条件，不能重复选一个人
((i != j && i != k && i != h && i != g) && (j != k && j != h && j != g)&& (k != h && k != g) && h != g)
02-试题 B: 不同子串
本题总分：5 分
【问题描述】
一个字符串的非空子串是指字符串中长度至少为 1 的连续的一段字符组成的串。例如，字符串aaab 有非空子串a, b, aa, ab, aaa, aab, aaab，一共 7 个。注意在计算时，只算本质不同的串的个数。
请问，字符串0100110001010001 有多少个不同的非空子串？
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
package q2019;import java.util.HashSet;
import java.util.Set;public class q2不同字串 {public static void main(String[] args) {// HashSet set = new HashSet();
// String s="0100110001010001";
// int n=s.length();
// while (n>0){// int dis=s.length()-n+1;
// for (int i=0;i<n;i++){// String ss=s.substring(i,i+dis);
// set.add(ss);
// }
// n--;
// }
// System.out.println(set.size());method2();}static void method2(){String s="0100110001010001";Set<String> set=new HashSet<>();//遍历s，双指针
// int j=0;int n=s.length();for(int i=0;i<n;i++){for (int j = i; j <n ; j++) {String substring = s.substring(i, j+1);//注意结尾是闭区间所以j+1！！set.add(substring);}}System.out.println(set.size());}
}
substring(int beginIndex):返回一个新字符串，它是此字符串的一个子字符串。
该子字符串始于指定索引处的字符，一直到此字符串末尾。
“unhappy”.substring(2) -> “happy”
substring(int beginIndex, int endIndex):返回一个新字符串, 它是此字符串的一个子字符串。
该子字符串从指定的 beginIndex 处开始, endIndex:到指定的 endIndex-1处结束。
[beginIndex, endIndex - 1]
03-试题 C: 数列求值
本题总分：10 分
【问题描述】
给定数列 1, 1, 1, 3, 5, 9, 17, …，从第 4 项开始，每项都是前 3 项的和。求第 20190324 项的最后 4 位数字。
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个 4 位整数（提示：答案的千位不为 0），在提交答案时只填写这个整数，填写多余的内容将无法得分。
package q2019;public class q3数列求和 {public static void main(String[] args) {int a=1;int b=1;int c=1;int d=0;for (int i = 1; i < 20190322; i++) {d=(a+b+c)%10000;//每一次只要后四位就行了a=b;b=c;c=d;}System.out.println(d);}/*此题类似于斐波那契数列，但是所求20190324项的最后四位数字，要是单纯按照斐波那契数列的思想求下去，
别说long类型，BigInteger类型都存不了这么大的数，然后我们发现，所求20190324项的最后四位数字
（也就是变相的告诉我们运算过程只和每个数的后四位有关系），那么我们只需要保留每次运算结果的后四位就OK了，这样绝对不会溢出。*/
}
04-试题 D: 数的分解
本题总分：10 分
【问题描述】
把 2019 分解成 3 个各不相同的正整数之和，并且要求每个正整数都不包含数字 2 和 4，一共有多少种不同的分解方法？
注意交换 3 个整数的顺序被视为同一种方法，例如 1000+1001+18 和 1001+1000+18 被视为同一种。
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
40785
方法一：太暴力了
package q2019;public class q4数的分解 {public static void main(String[] args) {// String a="123";CharSequence c1=new StringBuffer("2");CharSequence c2=new StringBuffer("4");
// boolean contains = a.contains(c2);
int cnt=0;for (int i = 0; i < 2019; i++) {for (int j = 0; j < 2019; j++) {for (int k = 0; k < 2019; k++) {String a = String.valueOf(i);String b = String.valueOf(j);String c = String.valueOf(k);if (i+j+k==2019 && !a.contains(c1)&&!a.contains(c2) && !b.contains(c1)&&!b.contains(c2) && !c.contains(c1)&&!c.contains(c2)){cnt++;}}}System.out.println(cnt);}System.out.println(cnt/6);}
}
方法二：
方法一1的改进
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NG4Po07A-1651583658470)(蓝桥杯真题2017-2021Img/image-20220404221833800.png)]
解题思路
首先我们规定a<b<c,这样就不会重复了，然后枚举a，b，c=2019-a-b，，当然在判断条件中不能忘记b<c
package q2019;public class q4数的分解 {public static void main(String[] args) {// String a="123";CharSequence c1=new StringBuffer("2");CharSequence c2=new StringBuffer("4");
// boolean contains = a.contains(c2);int cnt=0;for (int i = 1; i < 2019; i++) {for (int j = i+1; j < 2019&& 2019-i-j>j; j++) {int k=2019-i-j;String a = String.valueOf(i);String b = String.valueOf(j);String c = String.valueOf(k);if ( !a.contains(c1)&&!a.contains(c2) && !b.contains(c1)&&!b.contains(c2) && !c.contains(c1)&&!c.contains(c2)){//判断某个数字各个上面的数字是不是等于2|4cnt++;}}System.out.println(cnt);}System.out.println(check(13566));}static boolean check(int n){while (n>0){int t=n%10;if (t==2||t==4)return true;n/=10;}return false;}
}
05-试题 E: 迷宫
本题总分：15 分
【问题描述】
下图给出了一个迷宫的平面图，其中标记为 1 的为障碍，标记为 0 的为可以通行的地方。
010000
000100
001001
110000
迷宫的入口为左上角，出口为右下角，在迷宫中，只能从一个位置走到这个它的上、下、左、右四个方向之一。
对于上面的迷宫，从入口开始，可以按DRRURRDDDR 的顺序通过迷宫，一共 10 步。其中 D、U、L、R 分别表示向下、向上、向左、向右走。
对于下面这个更复杂的迷宫（30 行 50 列），请找出一种通过迷宫的方式，其使用的步数最少，在步数最少的前提下，请找出字典序最小的一个作为答案。请注意在字典序中D<L<R<U。（如果你把以下文字复制到文本文件中，请务必检查复制的内容是否与文档中的一致。再试题目录下有一个 maze.txt，内容与下面的文本相同）
01010101001011001001010110010110100100001000101010
00001000100000101010010000100000001001100110100101
01111011010010001000001101001011100011000000010000
01000000001010100011010000101000001010101011001011
00011111000000101000010010100010100000101100000000
11001000110101000010101100011010011010101011110111
00011011010101001001001010000001000101001110000000
10100000101000100110101010111110011000010000111010
00111000001010100001100010000001000101001100001001
11000110100001110010001001010101010101010001101000
00010000100100000101001010101110100010101010000101
11100100101001001000010000010101010100100100010100
00000010000000101011001111010001100000101010100011
10101010011100001000011000010110011110110100001000
10101010100001101010100101000010100000111011101001
10000000101100010000101100101101001011100000000100
10101001000000010100100001000100000100011110101001
00101001010101101001010100011010101101110000110101
11001010000100001100000010100101000001000111000010
00001000110000110101101000000100101001001000011101
10100101000101000000001110110010110101101010100001
00101000010000110101010000100010001001000100010101
10100001000110010001000010101001010101011111010010
00000100101000000110010100101001000001000000000010
11010000001001110111001001000011101001011011101000
00000110100010001000100000001000011101000000110011
10101000101000100010001111100010101001010000001000
10000010100101001010110000000100101010001011101000
00111100001000010000000110111000000001000000001011
10000001100111010111010001000110111010101101111000
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个字符串，包含四种字母 D、U、L、R，在提交答案时只填写这个字符串，填写多余的内容将无法得分。
package q2019;import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;@SuppressWarnings("all")
public class q5迷宫 {//1、接收数据public static void main(String[] args) {Scanner sc = new Scanner(System.in);char[][] a = new char[30][50];//字符数组for (int i = 0; i < 30; i++) {a[i] = sc.nextLine().toCharArray();}//是否要转化为整数数组int[][] aa = new int[30][50];for (int i = 0; i < 30; i++) {for (int j = 0; j < 50; j++) {aa[i][j] = a[i][j] - '0';}}System.out.println(BFS(aa, 30, 50));}static String BFS(int[][] labyrinth, int row, int col) {//labyrinth迷宫，row行，col列int[][] stepArr = {{-1, 0}, {0, 1}, {0, -1}, {1, 0}};String[] direction = {"U", "R", "L", "D"};int[][] visit = new int[row][col];//标记是否已经访问过StringBuilder sb = new StringBuilder();Node node = new Node(0, 0, -1, -1, 0, null);Queue<Node> queue = new LinkedList<>();Stack<Node> stack = new Stack<>();queue.offer(node);while (!queue.isEmpty()) {Node head = queue.poll();stack.push(head);//用于回溯路径visit[head.x][head.y] = 1;for (int i = 0; i < 4; i++) {int x = head.x + stepArr[i][0];int y = head.y + stepArr[i][1];String d = direction[i];if (x == row - 1 && y == col - 1 && labyrinth[x][y] == 0 && visit[x][y] == 0) {//到达了最后一个点//打印路径Node top = stack.pop();sb.append(d);sb.append(top.dection);int prx = top.preX;int prey = top.preY;while (!stack.isEmpty()) {top = stack.pop();if (prx == top.x && prey == top.y) {if (top.dection != null) {sb.append(top.dection);prey = top.y;prx = top.x;}}}return sb.reverse().toString();}//bfsif (x >= 0 && x < row && y>=0&&y < col && labyrinth[x][y] == 0 & visit[x][y] == 0) {queue.offer(new Node(x, y, head.preX, head.preY, head.step + 1, d));}}}return null;}static class Node {int x, y;int step;int preX, preY;String dection;public Node(int x, int y, int step, int preX, int preY, String dection) {this.x = x;this.y = y;this.step = step;this.preX = preX;this.preY = preY;this.dection = dection;}
}}
06-试题 F: 特别数的和
时间限制: 1.0s 内存限制: 512.0MB 本题总分：15 分
【问题描述】
小明对数位中含有 2、0、1、9 的数字很感兴趣（不包括前导 0），在 1 到 40 中这样的数包括 1、2、9、10 至 32、39 和 40，共 28 个，他们的和是 574。
请问，在 1 到 n 中，所有这样的数的和是多少？
【输入格式】
输入一行包含两个整数 n。
【输出格式】
输出一行，包含一个整数，表示满足条件的数的和。
【样例输入】
40
【样例输出】
574
【评测用例规模与约定】
对于 20% 的评测用例，1 ≤ n ≤ 10。
对于 50% 的评测用例，1 ≤ n ≤ 100。
对于 80% 的评测用例，1 ≤ n ≤ 1000。
对于所有评测用例，1 ≤ n ≤ 10000。
package q2019;import javafx.scene.transform.Scale;import java.util.Scanner;@SuppressWarnings("all")
public class q6特别数的和 {public static void main(String[] args) {Scanner sc=new Scanner(System.in);int n=sc.nextInt();String[] a = new String[n+1];for (int i = 1; i <=n; i++) {a[i]=i+" ";}int cnt=0;int ans=0;for (int i = 1; i <= n; i++) {if (a[i].contains("2")||a[i].contains("0")||a[i].contains("1")||a[i].contains("9")){cnt++;ans+=Integer.parseInt(a[i].trim());}}System.out.println(cnt);System.out.println(ans);}
}
07-试题 G: 外卖店优先级
时间限制: 1.0s 内存限制: 512.0MB 本题总分：20 分
【问题描述】
“饱了么”外卖系统中维护着 N 家外卖店，编号 1 ∼ N。每家外卖店都有 一个优先级，初始时 (0 时刻) 优先级都为 0。
每经过 1 个时间单位，如果外卖店没有订单，则优先级会减少 1，最低减 到 0；而如果外卖店有订单，则优先级不减反加，每有一单优先级加 2。
如果某家外卖店某时刻优先级大于 5，则会被系统加入优先缓存中；如果 优先级小于等于 3，则会被清除出优先缓存。
给定 T 时刻以内的 M 条订单信息，请你计算 T 时刻时有多少外卖店在优先缓存中。
【输入格式】
第一行包含 3 个整数 N、M 和 T。
以下 M 行每行包含两个整数 ts 和 id，表示 ts 时刻编号 id 的外卖店收到 一个订单。
【输出格式】
输出一个整数代表答案。
【样例输入】
2 6 6
1 1
5 2
3 1
6 2
2 1
6 2
【样例输出】
1
【样例解释】
6 时刻时，1 号店优先级降到 3，被移除出优先缓存；2 号店优先级升到 6，加入优先缓存。所以是有 1 家店 (2 号) 在优先缓存中。
【评测用例规模与约定】
对于 80% 的评测用例，1 ≤ N, M, T ≤ 10000。
对于所有评测用例，1 ≤ N, M, T ≤ 100000，1 ≤ ts ≤ T，1 ≤ id ≤ N。
public static void main(String[] args) {Scanner sc = new Scanner(System.in);int n = sc.nextInt();int m = sc.nextInt();int t = sc.nextInt();//定义brr[n][t]二维数组，表示第n个店的t时刻有多少订单int[][] brr = new int[n+1][t+1];int a =0;int b =0;for(int i=0;i<m;i++) {a = sc.nextInt();//第a时刻b = sc.nextInt();//第b个店brr[b][a]+=1;//在b店的a时刻的订单数}sc.close();int ans = 0;//用来记录这个店是否在缓存中的数量，即最终答案for(int i=1;i<n+1;i++) {int prior =0;//用于判断第i个店的优先级boolean position = false;//用于判断第i个店第j时刻是在缓存里还是缓存外for(int j=1;j<t+1;j++) {if(brr[i][j]==0) {//当第i个店的j时刻没有订单时，优先级要减一，同时最小为0prior-=1;prior = prior>=0?prior:0;}else {prior +=2*brr[i][j];//有订单，优先级则乘2}if(prior>5)position=true;//若此时优先级大于5，则在缓存里面if(prior<=3)position=false;//若此时优先级小于等于3，则肯定在缓存外面}if(position)ans++;//把第i个店的所以时间点都判断完，最终看这个店的位置，缓存里则ans加一}System.out.println(ans);
}
08-试题 H: 人物相关性分析
时间限制: 1.0s 内存限制: 512.0MB 本题总分：20 分
【问题描述】
小明正在分析一本小说中的人物相关性。他想知道在小说中 Alice 和 Bob 有多少次同时出现。
更准确的说，小明定义 Alice 和 Bob“同时出现”的意思是：在小说文本 中 Alice 和 Bob 之间不超过 K 个字符。
例如以下文本：
This is a story about Alice and Bob. Alice wants to send a private message to Bob.
假设 K = 20，则 Alice 和 Bob 同时出现了 2 次，分别是”Alice and Bob” 和”Bob. Alice”。前者 Alice 和 Bob 之间有 5 个字符，后者有 2 个字符。
注意:
Alice 和 Bob 是大小写敏感的，alice 或 bob 等并不计算在内。
Alice 和 Bob 应为单独的单词，前后可以有标点符号和空格，但是不能有字母。例如 Bobbi 并不算出现了 Bob。
【输入格式】
第一行包含一个整数 K。
第二行包含一行字符串，只包含大小写字母、标点符号和空格。长度不超过 1000000。
【输出格式】
输出一个整数，表示 Alice 和 Bob 同时出现的次数。
【样例输入】
20
This is a story about Alice and Bob. Alice wants to send a private message to Bob.
【样例输出】
2
【评测用例规模与约定】
对于所有评测用例，1 ≤ K ≤ 1000000。
他想知道在小说中 Alice 和 Bob 有多少次同时出现。
在小说文本 中 Alice 和 Bob 之间不超过 K 个字符
package q2019;import com.sun.webkit.graphics.WCRectangle;import java.util.Scanner;/*
This is a story about Alice and Bob. Alice wants to send a private message to Bob.
假设 K = 20，则 Alice 和 Bob 同时出现了 2 次，分别是”Alice and Bob” 和”Bob. Alice”。前者 Alice 和 Bob 之间有 5 个字符，后者有 2 个字符。*/@SuppressWarnings("all")
public class q8人物相关性分析 {static String a ;//"This is a story about Alice and Bob. Alice wants to send a private message to Bob."static String[] split;public static void main(String[] args) {Scanner sc=new Scanner(System.in);int K=sc.nextInt();//间隔
// sc.nextLine();sc.nextLine();a=sc.nextLine();
// System.out.println(s);sub();//下面开始计算alice和bobe出现了多少次int length=split.length;int []wordLength=new int[length];for (int i = 0; i < length; i++) {wordLength[i]=split[i].length();}int num=0;// Alice ——> Bob的距离for (int i = 0; i < length; i++) {if (split[i].equals("Alice")) {for (int j = i + 1; j < split.length; j++) {int sum = 1;if (split[j].equals("Bob")) {for (int k = i + 1; k < j; k++) {// 每个单词的长度加空格占据的长度sum += wordLength[k] + 1;}if (sum <= K) {num++;}}}}}// Bob ——> Alice的距离for (int i = 0; i < length; i++) {if (split[i].equals("Bob")) {for (int j = i + 1; j < split.length; j++) {int sum = 1;if (split[j].equals("Alice")) {for (int k = i + 1; k < j; k++) {// 每个单词的长度加空格占据的长度sum += wordLength[k] + 1;}if (sum <= K) {num++;}}}}}System.out.println(num);}static void sub(){//切割字符串+正则表达式/*\\s表示 空格,回车,换行等空白符,split("\\s+") 能实现 多个空格切割的效果+号表示一个或多个的意思这些字符有 | , + , * , ^ , $ , / , | , [ , ] , ( , ) , - , . , \等,因它们是正则表达式中的一部分, 所以如果想用该字符本身, 这些字符需要进行转义才能表示它本身；如果使用多个分隔符则需要借助 | 符号，如二所示，但需要转义符的仍然要加上分隔符进行处理*/split = a.split("\\s|\\,");//split的第二个参数表示限制切割的份数for (String s : split) {System.out.println(s);}}}
09-试题 I: 后缀表达式
时间限制: 1.0s 内存限制: 512.0MB 本题总分：25 分
【问题描述】
给定 N 个加号、M 个减号以及 N + M + 1 个整数 A1, A2, · · · , AN+M+1，小明想知道在所有由这 N 个加号、M 个减号以及 N + M + 1 个整数凑出的合法的后缀表达式中，结果最大的是哪一个？
请你输出这个最大的结果。
例如使用1 2 3 + -，则 “2 3 + 1 -” 这个后缀表达式结果是 4，是最大的。
【输入格式】
第一行包含两个整数 N 和 M。
第二行包含 N + M + 1 个整数 A1, A2, · · · , AN+M+1。
【输出格式】
输出一个整数，代表答案。
【样例输入】
1 1
1 2 3
【样例输出】
4
【评测用例规模与约定】
对于所有评测用例，0 ≤ N, M ≤ 100000，−109 ≤ Ai ≤ 109。
- 1.如果只有+号，没有-号，则遍历数组累加即可；
- 2.如果只有-号，没有+号，首先从小到大排序，然后分两种情况考虑：
- （1）.最小值是负数（也就是含有负数），例如[-2, -1, 3, 4, 5]，四个减号，运算过程为5 - (-1) - (-2 - 3 - 4) = 5 + 1 - (-9)
- = 5 + 1 + 9 = 15，也就是说只要含有负数，负数转正数，全部相加即可
- （2）.最小值是正数（全部是正数），例如[1, 2, 3]，两个减号，运算过程为3 - (1 - 2) = 3 + 2 - 1，也就是说运算规则为除了
最小值以外的正数相加减去最小值- 3.如果有+号，有-号，则讨论减号的个数与负数的个数，分两种情况讨论（实际分为三种）：
*（ 1）.减号个数大于等于负数个数（则将负数变正数，每一个负数变正数的过程中， 减号的数量需要减一，然后排序,遍历数组从大到小累加，- 直至剩下的数字个数和减号数量相同，然后再减去这些剩下的数字）；
- （2）.减号个数小于负数个数，这个时候我们就应该使用+号，消除负数（比如[2, -5 , -6, + , -]，运算过程为2 - ((-5) + (-6)) =
- 2 + 11 = 13）,我们可以再分情况讨论：
- （2.1）.全是负数，如[-1, -2, -3, -4, -5],其中一个加号三个减号，运算过程为（-1 - ((-4) + (-5)) - (-3) - (-2) = -1 + 9
- 3 + 2）,则运算规律为首先排序选择其中的最大值，加上其他数字的绝对值就行（可以自行继续证明）。（2.2）.有正数，有负数，
- [-1, 19, 17, -4, -5],其中两个加号两个减号，则运算过程为（19 + 17 - ((-4) + (-5)) - (-1) = 19 + 17 + 9 + 1）,则运算
- 规律为首先排序选择其中的最大值，加上其他数字的绝对值就行（可以自行继续证明）。所有情况讨论完毕。
package provincialGames_10_2019_JavaB;import java.util.Arrays;
import java.util.Scanner;public class I后缀表达式 {public static void main(String[] args) {Scanner input = new Scanner(System.in);try {int add = input.nextInt();int reduce = input.nextInt();int totalLength = add + reduce + 1;int[] number = new int[totalLength];for (int i = 0; i < totalLength; i++) {number[i] = input.nextInt();}int sum = 0;if (reduce == 0) {for (int i = 0; i < totalLength; i++) {sum += number[i];}}if (add == 0) {Arrays.sort(number);if (number[0] < 0) {for (int i = 0; i <= reduce; i++) {if (number[i] > 0)sum += number[i];elsesum -= number[i];}} else {for (int i = 1; i <= reduce; i++) {sum += number[i];}sum -= number[0];}}if (add != 0 && reduce != 0) {int reduceNum = 0;for (int i = 0; i < totalLength; i++) {if (number[i] < 0) {reduceNum++;}}if (reduce >= reduceNum) {Arrays.sort(number);int temp = reduce;for (int i = 0; i < reduceNum; i++) {number[i] = -number[i];temp--;}Arrays.sort(number);for (int i = totalLength - 1; i >= temp; i--) {sum += number[i];}for (int i = temp - 1; i >= 0; i--) {sum -= number[i];}} else {Arrays.sort(number);sum += number[totalLength - 1];for (int i = 0; i < totalLength - 1; i++) {if (number[i] > 0)sum += number[i];elsesum -= number[i];}}}System.out.println(sum);} catch (Exception e) {input.close();}}}
10-试题 J: 灵能传输
时间限制: 5.0s 内存限制: 512.0MB 本题总分：25 分
【题目背景】
在游戏《星际争霸 II》中，高阶圣堂武士作为星灵的重要 AOE 单位，在游戏的中后期发挥着重要的作用，其技能”灵能风暴“可以消耗大量的灵能对一片区域内的敌军造成毁灭性的伤害。经常用于对抗人类的生化部队和虫族的刺蛇飞龙等低血量单位。
【问题描述】
你控制着 n 名高阶圣堂武士，方便起见标为 1, 2, · · · , n。每名高阶圣堂武士需要一定的灵能来战斗，每个人有一个灵能值 ai 表示其拥有的灵能的多少（ai 非负表示这名高阶圣堂武士比在最佳状态下多余了 ai 点灵能，ai 为负则表示这名高阶圣堂武士还需要 −ai 点灵能才能到达最佳战斗状态）。现在系统赋予了你的高阶圣堂武士一个能力，传递灵能，每次你可以选择一个 i ∈ [2, n − 1]，若 ai ≥ 0 则其两旁的高阶圣堂武士，也就是 i − 1、i + 1 这两名高阶圣堂武士会从 i 这名高阶圣堂武士这里各抽取 ai 点灵能；若 ai < 0 则其两旁的高阶圣堂武士，也就是 i − 1, i + 1 这两名高阶圣堂武士会给 i 这名高阶圣堂武士 −ai 点灵能。形式化来讲就是 ai−1+ = ai , ai+1+ = ai , ai− = 2ai。
灵能是非常高效的作战工具，同时也非常危险且不稳定，一位高阶圣堂武士拥有的灵能过多或者过少都不好，定义一组高阶圣堂武士的不稳定度为 maxn i=1|ai |，请你通过不限次数的传递灵能操作使得你控制的这一组高阶圣堂武 士的不稳定度最小。
【输入格式】
本题包含多组询问。输入的第一行包含一个正整数 T 表示询问组数。
接下来依次输入每一组询问。
每组询问的第一行包含一个正整数 n，表示高阶圣堂武士的数量。
接下来一行包含 n 个数 a1, a2, · · · , an。
【输出格式】
输出 T 行。每行一个整数依次表示每组询问的答案。
【样例输入】
3
3
5 -2 3
4
0 0 0 0
3
1 2 3
【样例输出】
3
0
3
【样例说明】
对于第一组询问：
对 2 号高阶圣堂武士进行传输操作后 a1 = 3，a2 = 2，a3 = 1。答案为 3。
对于第二组询问：
这一组高阶圣堂武士拥有的灵能都正好可以让他们达到最佳战斗状态。
【样例输入】
3
4
-1 -2 -3 7
4
2 3 4 -8
5
-1 -1 6 -1 -1
【样例输出】
5
7
4
【样例输入】
见文件trans3.in。
【样例输出】
见文件trans3.ans。
【数据规模与约定】
对于所有评测用例，T ≤ 3，3 ≤ n ≤ 300000，|ai | ≤ 109。
评测时将使用 25 个评测用例测试你的程序，每个评测用例的限制如下：
注意：本题输入量较大请使用快速的读入方式。
2020年第二场真题
一、试题 A: 门牌制作——答案：641
package q2020;/*
【问题描述】
小蓝要为一条街的住户制作门牌号。
这条街一共有 2020 位住户，门牌号从 1 到 2020 编号。
小蓝制作门牌的方法是先制作 0 到 9 这几个数字字符，最后根据需要将字符粘贴到门牌上，例如门牌 1017 需要依次粘贴字符 1、0、1、7，即需要 1 个 字符 0，2 个字符 1，1 个字符 7。
请问要制作所有的 1 到 2020 号门牌，总共需要多少个字符 2？
【答案提交】*/
public class q1门牌制作 {public static void main(String[] args) {int ans = 0;for (int i = 1; i <= 2020; i++) {//注意！！//如果直接对i进行操作，每一个i算出来的结果都为0，然后i++，i=1，无限循环int x = i;while (x > 0) {if (x % 10 == 2) ans++;x /= 10;}}System.out.println(ans);}
}
二、试题 B: 寻找 2020——答案：16520
package q2020;import java.util.Scanner;/*
小蓝有一个数字矩阵，里面只包含数字 0 和 2。小蓝很喜欢 2020，他想找到这个数字矩阵中有多少个 2020 。
小蓝只关注三种构成 2020 的方式：
• 同一行里面连续四个字符从左到右构成 2020。
• 同一列里面连续四个字符从上到下构成 2020。
• 在一条从左上到右下的斜线上连续四个字符，从左上到右下构成 2020。*/
public class q2寻找2020 {public static void main(String[] args) {//1接受一个300x300的矩阵char [][] b=new char[300][300];Scanner sc=new Scanner(System.in);for (int i = 0; i < 300; i++) {b[i]=sc.nextLine().toCharArray();}int [][]a=new int[300][300];for (int i = 0; i <300; i++) {for (int j = 0; j < 300; j++) {a[i][j]=b[i][j]-'0';}}//满足三种条件就可以++int ans=0;int n=300;for (int i = 0; i <n ; i++) {for (int j = 0; j < n; j++) {//极限情况要考虑！！每一种情况都要不超出300if (j+3<n&&a[i][j]==2&&a[i][j+1]==0&&a[i][j+2]==2&&a[i][j+3]==0)ans++;if (i+3<n&&a[i][j]==2&&a[i+1][j]==0&&a[i+2][j]==2&&a[i+3][j]==0)ans++;if (j+3<n&&i+3<n&&a[i][j]==2&&a[i+1][j+1]==0&&a[i+2][j+2]==2&&a[i+3][j+3]==0)ans++;}}System.out.println(ans);}
}
三、试题 C: 蛇形填数——答案：761
package q2020;public class q3蛇形填数 {/*问题描述】
如下图所示，小明用从 1 开始的正整数“蛇形”填充无限大的矩阵。1 2 6 7 15 ...3 5 8 14 ...4 9 13 ...10 12 ...11 ......
容易看出矩阵第二行第二列中的数是 5。请你计算矩阵中第 20 行第 20 列的数是多少？*/public static void main(String[] args) {//761int a1=1;int aa=0;for (int i = 2; i <=20 ; i++) {aa=a1+4*(i-1);a1=aa;}System.out.println(aa);}
}
四、试题 D: 七段码——答案：80
问题描述】
小蓝要用七段码数码管来表示一种特殊的文字。
上图给出了七段码数码管的一个图示，数码管中一共有 7 段可以发光的二 极管，分别标记为 a, b, c, d, e, f, g。
小蓝要选择一部分二极管（至少要有一个）发光来表达字符。在设计字符 的表达时，要求所有发光的二极管是连成一片的。
例如：b 发光，其他二极管不发光可以用来表达一种字符。
例如：c 发光，其他二极管不发光可以用来表达一种字符。这种方案与上一行的方案可以用来表示不同的字符，尽管看上去比较相似。
例如：a, b, c, d, e 发光，f, g 不发光可以用来表达一种字符。
例如：b, f 发光，其他二极管不发光则不能用来表达一种字符，因为发光 的二极管没有连成一片。
请问，小蓝可以用七段码数码管表达多少种不同的字符？
package q2020;/*
上图给出了七段码数码管的一个图示，数码管中一共有 7 段可以发光的二 极管，分别标记为 a, b, c, d, e, f, g。
小蓝要选择一部分二极管（至少要有一个）发光来表达字符。在设计字符 的表达时，要求所有发光的二极管是连成一片的。
例如：b 发光，其他二极管不发光可以用来表达一种字符。
例如：c 发光，其他二极管不发光可以用来表达一种字符。这种方案与上一行的方案可以用来表示不同的字符，尽管看上去比较相似。
例如：a, b, c, d, e 发光，f, g 不发光可以用来表达一种字符。
例如：b, f 发光，其他二极管不发光则不能用来表达一种字符，因为发光 的二极管没有连成一片。
请问，小蓝可以用七段码数码管表达多少种不同的字符？*/
public class q4七段码 {/*** @param args* 本题的大致思路是将数码管的七段进行全排列（用数字代表数码管字段,0代表a，1代表b,以此类推）然后将这7个数字的所有可能全部排列（从7个数字中取m（1<=m<=7）进行排列）列举出来* 得到所有的取值情况，再判断每种情况构成的图是否连通，若连通，sum++* 进行排列时需要注意，一定要保证每个排列必须是递增或者递减,这样才能不重复，例如：012,021,210等等，它们都表示数码管中取出ABC这一种情况*/static boolean[][] M;//M是邻接矩阵static int[] a;//a代表排列组合的数字static int sum = 0;//最后结果public static void main(String[] args) {/*M是邻接矩阵，根据数码管图像可以得到* 例如：a和b,a和f都可以连通，那么代表0和1,0和5连通*/M = new boolean[7][7];M[0][1] = M[1][0] = M[0][5] = M[5][0] = true;M[1][2] = M[2][1] = M[1][6] = M[6][1] = true;M[2][3] = M[3][2] = M[2][6] = M[6][2] = true;M[4][3] = M[3][4] = true;M[4][5] = M[5][4] = M[4][6] = M[6][4] = true;M[5][6] = M[6][5] = true;a = new int[7];for (int i = 0; i < a.length; i++) {a[i] = i;}//所有排列的可能，深搜for (int n = 1; n <= 7; n++) {dfs(0, n);}System.out.println(sum);}public static void dfs(int k, int n) {if (k == n) {//如果只有一个数,那么这种情况下必然成立if (n == 1) {sum++;return;}//判断，这种情况下的图是否连通。用的是并查集方法//初始化int[] pre = new int[n];for (int i = 0; i < pre.length; i++) {pre[i] = i;}for (int i = 0; i < n; i++) {for (int j = i + 1; j < n; j++) {//两层for穷举所有边的情况//若i和j连通,j加入i//i和j代表的是结点，所以并的时候就是jion(pre, i,j)。但是i代表的结点好j代表的结点是否连通，则需要看a[i]]和[a[j]在邻接矩阵M中是否为真if (M[a[i]][a[j]]) {jion(pre, i, j);}}}//到最后，若所有结点都连通，则所有结点的跟结点应该都一样。否则说明此情况下的图不连通boolean flag = true;for (int i = 1; i < pre.length; i++) {if (find(pre, 0) != find(pre, i)) {flag = false;break;}}if (flag) {sum++;}return;}//dfs，深搜for (int i = k; i < a.length; i++) {if (k == 0 || a[i] > a[k - 1]) {int t = a[i];a[i] = a[k];a[k] = t;dfs(k + 1, n);t = a[i];a[i] = a[k];a[k] = t;}}}//查找根节点public static int find(int[] pre, int node) {int son = node, temp = 0;//查找根节点while (node != pre[node]) {node = pre[node];}//路径优化while (son != node) {temp = pre[son];//直接通跟pre[son] = node;//son向上走一格son = pre[son];}return node;}//两个结点相并public static void jion(int[] pre, int x, int y) {int fx = find(pre, x);int fy = find(pre, y);//两个结点属于不同图，相并if (fx != fy) {pre[fy] = fx;}}
}
五、试题 E: 排序——jonmlkihgfedcba
package q2020;import java.util.Scanner;public class q5排序 {/*
【问题描述】
小蓝最近学习了一些排序算法，其中冒泡排序让他印象深刻。
在冒泡排序中，每次只能交换相邻的两个元素。
小蓝发现，如果对一个字符串中的字符排序，只允许交换相邻的两个字符，则在所有可能的排序方案中，{{冒泡排序的总交换次数是最少的}}。
例如，对于字符串 lan 排序，只需要 1 次交换。对于字符串 qiao 排序，总共需要 4 次交换。
小蓝找到了很多字符串试图排序，他恰巧碰到一个字符串，需要 100 次交换，可是他忘了吧这个字符串记下来，现在找不到了。
请帮助小蓝找一个只包含小写英文字母且没有字母重复出现的字符串，对该串的字符排序，正好需要 100 次交换。如果可能找到多个，请告诉小蓝最短的那个。如果最短的仍然有多个，请告诉小蓝字典序最小的那个。请注意字符串中可以包含相同的字符。
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个只包含小写英文字母的字符串，在提交答案时只填写这个字符串，填写多余的内容将无法得分。*/public static void main(String[] args) {int a1 = 1;Scanner sc = new Scanner(System.in);int n = sc.nextInt();int aa = 0;int num[] = new int[100];int j = 0;for (int i = 2; i < n; i++) {aa = a1 + i;a1 = aa;num[j++]=aa;}System.out.println(aa);for (int i : num) {System.out.print(i+" ");}//3 6 10 15 21 28 36 45 55 66 78 91 105 120
//长度 3 4 15//得到长度为15的字母串，交换顺序为105>100，这样就找到了倒过来的字母顺序//onmlkjihgfedcba//为了减少5次排序，我们可以将第六位j调到最前面，这样j就和第1，2，3，4，5位不交换，减少了5次排序/*冒泡排序，要求字符串最短，那就假设完全逆序，设长度为n，则移动次数为 n*(n-1)/2，要求移动次数恰好大于100，则 n=15；移动次数105。要求字典序最小，则把第六个字符移动到第一个位置，前五个字符后移一位。纯逻辑推导，无代码。*/}
}
六、试题 F: 成绩分析
问题描述
小蓝给学生们组织了一场考试，卷面总分为
分，每个学生的得分都是一个 到
的整数。
请计算这次考试的最高分、最低分和平均分。
输入格式
输入的第一行包含一个整数
，表示考试人数。
接下来
行，每行包含一个 至
的整数，表示一个学生的得分。
输出格式
输出三行。
第一行包含一个整数，表示最高分。
第二行包含一个整数，表示最低分。
第三行包含一个实数，四舍五入保留正好两位小数，表示平均分。
样例输入
7
80
92
56
74
88
99
10
Data
样例输出
99
10
71.29
package q2020;import java.util.Arrays;
import java.util.Scanner;@SuppressWarnings("all")
public class q6成绩分析 {// // String.format("%.2f", xxx)：自动四舍五入 xxx要是double\float类型，int不行public static void main(String[] args) {Scanner sc = new Scanner(System.in);int n = sc.nextInt();//考试人数int[] a = new int[n];for (int i = 0; i < n; i++) {a[i] = sc.nextInt();}Arrays.sort(a);float sum = 0;for (int i = 0; i < a.length; i++) {sum += a[i];}
// double aver = ;//要四舍五入保留两位小数 float 71.0System.out.println(a[n - 1]);System.out.println(a[0]);System.out.println(String.format("%.2f",sum / n));}
}
7单词分析
/*问题描述】
小蓝学了很长时间也记不住一些单词，他准备不再完全记忆这些单词，而是根据单词中{(哪个字母出现得最多来分辨单词)}。
现在，请你帮助小蓝，给了一个单词后，帮助他找到出现最多的字母和这个字母出现的次数。
【输入格式】
输入一行包含一个单词，单词只由小写英文字母组成。
【输出格式】
输出两行，第一行包含一个英文字母，表示单词中出现得最多的字母是哪个。如果有多个字母出现的次数相等，输出字典序最小的那个。
第二行包含一个整数，表示出现得最多的那个字母在单词中出现的次数。
【样例输入】
lanqiao
【样例输出】
a
2
【样例输入】
longlonglongistoolong
【样例输出】
o
6*/@SuppressWarnings("all")
package q2020;import java.util.Scanner;
public class q7单词分析 {public static void main(String[] args) {//注意本题小心点：//最后输出字符的时候我们要将其//我们使用一个24位的数组存放每个单词出现的次数，然后找到最大值int[] a = new int[26];//!!!!!!!!!!!!!!!!!!!Scanner sc = new Scanner(System.in);String s = sc.next();char[] schar=s.toCharArray();//遍历这个char, a--0 从a变成了相对位置 0，for (int i = 0; i < schar.length; i++) {a [schar[i]-'a']++;}//找最大值int max=Integer.MIN_VALUE;int index=0;//相对位置for (int i = 0; i < a.length; i++) {if (max<a[i]){max=a[i];index=i;}}//将
// System.out.println((char)('a'+index));
// System.out.println(max);System.out.println((char) ('a' + index) + "\n" + max);}
}
八、试题 H: 数字三角形3
package q2020;import java.util.Scanner;import static java.lang.Math.max;/*对于每条路径，把路径上面的数加起来可以得到一个和，你的任务就是找到最大的和。
路径上的每一步只能从一个数走到下一层和它最近的左边的那个数或者右边的那个数。
((((((此外，向左下走的次数与向右下走的次数相差不能超过 1。))))))
【输入格式】
输入的第一行包含一个整数 N (1 < N ≤ 100)，表示三角形的行数。下面的 N 行给出数字三角形。数字三角形上的数都是 0 至 100 之间的整数。
【输出格式】
输出一个整数，表示答案。
【样例输入】
5
7
3 8
8 1 0
2 7 4 4
4 5 2 6 5
【样例输出】
27*/@SuppressWarnings("all")
public class q7数字三角形改 {public static void main(String[] args) {mythed();System.out.println(df3());}static void mythed(){Scanner sc = new Scanner(System.in);int n = sc.nextInt();int[][] a = new int[n][];//首先定义它位n行，因为列还不确定for (int i = 0; i < n; i++) {a[i] = new int[i + 1];//因为元素个数每一层都是此层的序号加1，所以定义如此长度for (int j = 0; j < i + 1; j++) {//j要去得到i个元素a[i][j] = sc.nextInt();}}//dpSystem.out.println(dp2(a, 0, 0));System.out.println(dp1(a, 0, 0));//看看别人怎么做的}//自底向上的递推，使用滚动数组进行优化 失败static int dp2(int[][] a, int i, int j) {int row = a.length;//hanint col = a[row - 1].length;//lieint[] dp = new int[col];for (int k = 0; k < col; k++) {dp[k] = a[row - 1][k];}for (int k = row - 2; k >= 0; k--) {for (int l = 0; l <= k; l++) {dp[l] = a[k][l] + Math.max(dp[l], dp[l + 1]);//递归公式}}for (int i1 : dp) {System.out.print(i1+" ");}System.out.println();return dp[0];}//递推法 失败！static int dp1(int[][] a, int i, int j) {int row = a.length;if (i == row - 1) {return a[i][j];} else {int v1 = dp1(a, i + 1, j);int v2 = dp1(a, i + 1, j + 1);return a[i][j] + Math.max(v1, v2);}}static int df3() {Scanner sc = new Scanner(System.in);int n = sc.nextInt();int arr[][] = new int[n + 1][n + 1];for (int i = 1; i <= n; i++) {for (int j = 1; j <= i; j++) {arr[i][j] = sc.nextInt();arr[i][j] += Math.max(arr[i - 1][j - 1], arr[i - 1][j]);}}for (int[] ints : arr) {for (int anInt : ints) {System.out.print(anInt+" ");}System.out.println();}return (n % 2 == 1 ? arr[n][n / 2 + 1] : Math.max(arr[n][n / 2], arr[n][n / 2 + 1]));}
}
九、试题 I: 子串分值和
package q2020;import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;public class q9子串分值和 {/*【问题描述】
对于一个字符串 S，我们定义 S 的分值 f(S ) 为 S 中出现的不同的字符个数。例如 f(”aba”) = 2，f(”abc”) = 3, f(”aaa”) = 1。
现在给定一个字符串 S [0..n − 1]（长度为 n），请你计算对于所有 S 的非空子串 S [i.. j](0 ≤ i ≤ j < n)，f(S [i.. j]) 的和是多少。
【输入格式】
输入一行包含一个由小写字母组成的字符串 S。
【输出格式】
输出一个整数表示答案。
【样例输入】
ababc
【样例输出】
28
【样例说明】
子串 f值
a 1
ab 2
aba 2
abab 2
ababc 3
b 1
ba 2
bab 2
babc 3
a 1
ab 2
abc 3
b 1
bc 2
c 1*/public static void main(String[] args) {//我的解题思路/*求一个字符串的非空子集，所有然后分别计算这些非空子集额的数值，最后求和method1*///生成子集
// char[]a={'a','b','a','b','c'};
// Set<Set<Character>> subsets3 = getSubsets3(a, a.length);
// System.out.println(subsets3);//[[], [a], [b], [c], [a, b], [a, c], [b, c], [a, b, c]]// method2();method1();}static void method2() {Scanner sc = new Scanner(System.in);String s = sc.next();//接受字符串char[] c = s.toCharArray();long ans = 0;for (int i = 0; i < c.length; i++) {HashSet<Character> set = new HashSet<Character>();//hashset去重for (int j = i; j < c.length; j++) {set.add(c[j]);ans += set.size();}}System.out.println(ans);}static void method1() {//思路：利用HashSet 元素不能重复的特点//将字符串从i,到j位进行分割，分割后的字串在进行去重，所有去重后字串的长度相加输出即可。Scanner scan = new Scanner(System.in);String str = scan.nextLine();String arr[] = new String[100000];int k = 0;int count = 0;//要学习的地方for (int i = 0; i < str.length(); i++) {for (int j = i + 1; j <= str.length(); j++) {//对字符串进行截取，并加到数组中arr[k] = str.substring(i, j);//生成不同字串k++;}}//for (int i = 0; i < k; i++) {Set<String> set = new HashSet<String>();//利用HashSet元素不会重复的特点，计算子串的分值for (int j = 0; j < arr[i].length(); j++) {set.add(arr[i].charAt(j) + "");}count += set.size();}System.out.print(count);}static Set<Set<Character>> getSubsets3(char[] A, int n) {// Arrays.sort(A);return getSubsets3Core(A, n, n - 1);}static Set<Set<Character>> getSubsets3Core(char[] A, int n, int cur) {Set<Set<Character>> newSet = new HashSet<>();if (cur == 0) {//处理第一个元素Set<Character> nil = new HashSet<>();//空集Set<Character> first = new HashSet<>();//包含第一个元素的集合first.add(A[0]);newSet.add(nil);newSet.add(first);return newSet;}Set<Set<Character>> oldSet = getSubsets3Core(A, n, cur - 1);for (Set<Character> set : oldSet) {//对于每个子集,cur这个元素可以加进去,也可以不加进去newSet.add(set);//保留原样Set<Character> clone = (Set<Character>) ((HashSet) set).clone();clone.add(A[cur]);//添加当前元素newSet.add(clone);}return newSet;}}
总结
做对5题就行><
2021年真题
试题A:ASC
本题总分：5分
【问题描述】
已知大写字母A的ASCI码为65，请问大写字母L的ASCⅡ码是多少？
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一
个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aHS1L3mV-1651583658471)(蓝桥杯真题2017-2021Img/image-20220406203325959.png)]
76
package q2021;public class q1 {
// 已知大写字母A的ASCI码为65，请问大写字母L的ASCⅡ码是多少？
public static void main(String[] args) {System.out.println("A".hashCode());System.out.println("L".hashCode());
}
}
Q2卡片
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rsaeNObh-1651583658471)(蓝桥杯真题2017-2021Img/image-20220406203541973.png)]
package q2021;import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Objects;
import java.util.Set;public class q3直线 {/*在平面直角坐标系中，两点可以确定一条直线。如果有多点在一条直线上，那么这些点中任意两点确定的直线是同一条。给定平面上2×3个整点(x,y)0≤x<2,0≤y<3,x∈Z,yeZ,即横坐标是0到1（包含0和1）之间的整数、纵坐标是0到2（包含0和2）之间的整数的点。这些点一共确定了11条不同的直线。给定平面上20×21个整点{(x,y)0≤x<20,0≤y<21,x∈Z,y∈Z,即横坐标是0到19（包含0和19）之间的整数、纵坐标是0到20（包含0和20）之间的整数的点。请问这些点一共确定了多少条不同的直线。思路枚举每一个起点和终点，然后用y=kx+b计算出斜率，然后去重*/static int gcd(int a,int b) {//求a和b的最大公约数if (b==0) {return a;}return gcd(b, a%b);}public static void main(String[] args) {method2();}static void method(){Set<Line> lines=new HashSet<Line>();List<Point> points=new ArrayList<Point>();for(int i=0;i<20;i++) {//寻找所有的点for (int j = 0; j < 21; j++) {Point p=new Point();//定义一个pointp.x=i;p.y=j;points.add(p);//放入到列表中}}//双重循环，每一个元素都和其他的点进行比较for (int i = 0; i < points.size(); i++) {Point p1=points.get(i);for (int j = 0; j < points.size(); j++) {if (i!=j) {Point p2=points.get(j);Line l=new Line();//生成一个直线if (p2.x==p1.x) {l.b=String.valueOf(p1.x);}else {int kt=p2.y-p1.y;int kd=p2.x-p1.x;int gcd=gcd(kt, kd);kt/=gcd;kd/=gcd;if (kd==0) {l.k=String.valueOf(0);l.b=String.valueOf(p1.y);lines.add(l);continue;}if ((kt<0)^(kd<0)) {l.k=-Math.abs(kt)+"/"+Math.abs(kd);}else {l.k=Math.abs(kt)+"/"+Math.abs(kd);}kt=p1.y+kd-kt+p1.x;gcd(kt,kd);kt/=gcd;kd/=gcd;if (kt==0) {l.b="0";lines.add(l);continue;}if ((kt<0)^(kd<0)) {l.b=-Math.abs(kt)+"/"+Math.abs(kd);}else {l.b=Math.abs(kt)+"/"+Math.abs(kd);}}lines.add(l);}}}System.out.println(lines.size());}static void method2(){//四层for循环遍历每个点，用set去重Set<String> set=new HashSet<>();for (int x1 = 0; x1 < 20; x1++) {for (int y1 = 0; y1 < 21; y1++) {for (int x2 = 0; x2 < 20; x2++) {for (int y2 = 0; y2 < 21; y2++) {if (x1==x2&&y1==y2) continue;//相同的点跳过//k=(y1-y2)/(x1-x2)if (x1==x2){//x1-x2=0,斜率正无穷,set.add("x="+String.valueOf(x1));//x=1,x=2,x=3........}else {int y=y1-y2,x=x1-x2;//由于可能会有分子分母没有约分的情况，所以先求最大公约数int _gcd=gcd(Math.abs(x),Math.abs(y));x/=_gcd;//化成最简形式y/=_gcd;if (x>0&&y<0){x=-x;y=-y;}if (x*y>0){x=Math.abs(x);y=Math.abs(y);}if (y==0) x=Math.abs(x);//求bint by=x2*y1-x1*y2;int bx=x2-x1;_gcd=gcd(Math.abs(bx),Math.abs(by));by/=_gcd;bx/=_gcd;if (bx>0&&by<0){bx=-bx;by=-by;}if (bx*by>0){bx=Math.abs(bx);by=Math.abs(by);}if (by==0) bx=Math.abs(bx);set.add(String.valueOf(y)+"/"+String.valueOf(x)+" "+String.valueOf(by)+"/"+String.valueOf(bx));}}}}}System.out.println(set.size());}
}class Line{String k;String b;public Line() {super();// TODO Auto-generated constructor stub}public Line(String k, String b) {super();this.k = k;this.b = b;}@Override// 直线是否相等public boolean equals(Object obj) {Line line=(Line) obj;return Objects.equals(k, line.k)&& Objects.equals(b, line.b);}@Overridepublic int hashCode() {int res=k!=null?k.hashCode():0;res=31*res+(b!=null?b.hashCode():0);return res;}
}class Point{int x;int y;
}q3直线
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bR1CeeZe-1651583658472)(蓝桥杯真题2017-2021Img/image-20220406203736481.png)]
package q2021;import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
// 小蓝希望所有的货物最终摆成一个大的长方体。即在长、宽、高的方向上分别堆L、W、H的货物，满足n=L×W×H。public class q4货物摆放 {public static void main(String[] args) {// method1();//超时method2();
// System.out.println(10%2);//0
// System.out.println((int)Math.sqrt(2021041820210418L));}static void method1(){long n=2021041820210418L;int ans = 0;int m = 0;for (long i = 1; i <= n; i++) {for (long j = 1; j <= n; j++) {long k = (n / i) / j;if ((i * j * k) == n) {ans++;}System.out.println(ans);}}}static int gcd(int a, int b){if (b==0)return a;return gcd(b,a%b);}static void method2() {//从题目中我们可以知道，当 n = 4 时，有以下 6 种方案：1×1×4、1×2×2、1×4×1、2×1×2、2 × 2 × 1、4 × 1 × 1。/*其实就是求n的所有公因子的全排列的乘积满足的情况*///1我们使用arraylist存放公因子List<Long> yz = new ArrayList<>();long n = 2021041820210418L;//要注意的一点是得对大数取个平方根，//求其公yzfor (long i = 1; i <= (int)Math.sqrt(n); i++) {if (n%i==0){//如果i是n的余数yz.add(i);yz.add(n/i);}}//求所有的情况，三层循环int cnt=0;//方案数long size=yz.size();for (int i = 0; i < size; i++) {for (int j = 0; j < size; j++) {for (int k = 0; k < size; k++) {if (yz.get(i)*yz.get(j)*yz.get(k)==n) cnt++;}}}System.out.println(yz.size());System.out.println(cnt);}static void method2(long n) {//从题目中我们可以知道，当 n = 4 时，有以下 6 种方案：1×1×4、1×2×2、1×4×1、2×1×2、2 × 2 × 1、4 × 1 × 1。/*其实就是求n的所有公因子的全排列的乘积满足的情况*///1我们使用arraylist存放公因子List<Long> yz = new ArrayList<>();//要注意的一点是得对大数取个平方根，//求其公yzfor (long i = 1; i <= (int)Math.sqrt(n); i++) {if (n%i==0){//如果i是n的余数yz.add(i);yz.add(n/i);}}//求所有的情况，三层循环int cnt=0;//方案数long size=yz.size();for (int i = 0; i < size; i++) {for (int j = 0; j < size; j++) {for (int k = 0; k < size; k++) {if (yz.get(i)*yz.get(j)*yz.get(k)==n) cnt++;}}}System.out.println(cnt);}
}
q4货物摆放
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fx0o2YmU-1651583658472)(蓝桥杯真题2017-2021Img/image-20220406203748576.png)]
package q2021;import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
// 小蓝希望所有的货物最终摆成一个大的长方体。即在长、宽、高的方向上分别堆L、W、H的货物，满足n=L×W×H。public class q4货物摆放 {public static void main(String[] args) {// method1();//超时method2();
// System.out.println(10%2);//0
// System.out.println((int)Math.sqrt(2021041820210418L));}static void method1(){long n=2021041820210418L;int ans = 0;int m = 0;for (long i = 1; i <= n; i++) {for (long j = 1; j <= n; j++) {long k = (n / i) / j;if ((i * j * k) == n) {ans++;}System.out.println(ans);}}}static int gcd(int a, int b){if (b==0)return a;return gcd(b,a%b);}static void method2() {//从题目中我们可以知道，当 n = 4 时，有以下 6 种方案：1×1×4、1×2×2、1×4×1、2×1×2、2 × 2 × 1、4 × 1 × 1。/*其实就是求n的所有公因子的全排列的乘积满足的情况*///1我们使用arraylist存放公因子List<Long> yz = new ArrayList<>();long n = 2021041820210418L;//要注意的一点是得对大数取个平方根，//求其公yzfor (long i = 1; i <= (int)Math.sqrt(n); i++) {if (n%i==0){//如果i是n的余数yz.add(i);yz.add(n/i);}}//求所有的情况，三层循环int cnt=0;//方案数long size=yz.size();for (int i = 0; i < size; i++) {for (int j = 0; j < size; j++) {for (int k = 0; k < size; k++) {if (yz.get(i)*yz.get(j)*yz.get(k)==n) cnt++;}}}System.out.println(yz.size());System.out.println(cnt);}static void method2(long n) {//从题目中我们可以知道，当 n = 4 时，有以下 6 种方案：1×1×4、1×2×2、1×4×1、2×1×2、2 × 2 × 1、4 × 1 × 1。/*其实就是求n的所有公因子的全排列的乘积满足的情况*///1我们使用arraylist存放公因子List<Long> yz = new ArrayList<>();//要注意的一点是得对大数取个平方根，//求其公yzfor (long i = 1; i <= (int)Math.sqrt(n); i++) {if (n%i==0){//如果i是n的余数yz.add(i);yz.add(n/i);}}//求所有的情况，三层循环int cnt=0;//方案数long size=yz.size();for (int i = 0; i < size; i++) {for (int j = 0; j < size; j++) {for (int k = 0; k < size; k++) {if (yz.get(i)*yz.get(j)*yz.get(k)==n) cnt++;}}}System.out.println(cnt);}
}
Q5路径
【问题描述】
小蓝学习了最短路径之后特别高兴，他定义了一个特别的图，希望找到图
中的最短路径。
小蓝的图由 2021 个结点组成，依次编号 1 至 2021。
对于两个不同的结点 a, b，如果 a 和 b 的差的绝对值大于 21，则两个结点之间没有边相连；如果 a 和 b 的差的绝对值小于等于 21，则两个点之间有一条长度为 a 和 b 的最小公倍数的无向边相连。
例如：结点 1 和结点 23 之间没有边相连；结点 3 和结点 24 之间有一条无向边，长度为 24；结点 15 和结点 25 之间有一条无向边，长度为 75。
请计算，结点 1 和结点 2021 之间的最短路径长度是多少。
package q2021;public class Q5路径 {static int N = 2022;static int[][] g = new int[N][N];//NxN的图》》邻接矩阵static int gcd(int a, int b){if (b==0)return a;return gcd(b,a%b);}public static void main(String[] args) {//最短路径 {{floyd}} 、dijktra、 spfa//最短生成树 prim kruskal//初始化for (int i = 1; i <= 2021; i++) {for (int j = 1; j <= 2021; j++) {g[i][j] = 0x3f3f3f3f;//相比于0x7fffffff它不会溢出}}
// 构图for (int i = 1; i <= 2021; i++) {for (int j = 1; j <= 2021; j++) {if (Math.abs(i - j) <= 21) g[i][j] = i * j / gcd(i, j);//a和b的最小公倍数，就是其乘积/最大公约数（gcd)}}//最短路径模板for (int k = 1; k <= 2021; k++) {for (int i = 1; i <= 2021; i++) {for (int j = 1; j <= 2021; j++) {g[i][j] = Math.min(g[i][j], g[i][k] + g[k][j]);}}}System.out.println(g[1][2021]);
// System.out.println(0x3f3f3f3f);//1061109567/*总结一下：我们要计算一个图的最短路径，有很多方法，但是对于本题来说使用floyd算法比较简单首先定义一个图（使用邻接矩阵）、初始化它接下来构造他，即重新赋值最后使用floyd算法求最短路径。 */}//10266837
}
q6时间显示
小蓝要和朋友合作开发一个时间显示的网站。在服务器上，朋友已经获取了当前的时间，用一个整数表示，值为从 1970 年 1 月 1 日 00:00:00 到当前时刻经过的毫秒数。
现在，小蓝要在客户端显示出这个时间。小蓝不用显示出年月日，只需要
显示出时分秒即可，毫秒也不用显示，直接舍去即可。给定一个用整数表示的时间，请将这个时间对应的时分秒输出。
【样例输入 1】
46800999
【样例输出 1】
13:00:00
【样例输入 2】
1618708103123
【样例输出 2】
01:08:23
package q2021;import sun.net.www.http.Hurryable;import java.util.Scanner;public class qF时间显示 {public static void main(String[] args) {method2();}static void method(){long s = 1618708103123l / 1000;//秒long h = s / 3600;//消失long x=h;int hnum = 0;while (h > 24) {h -= 24;hnum++;}long left=s-hnum*24*3600;//剩下的秒long m=left/60;long y=m;int mnum=0;while (y>60){y-=60;mnum++;}long lefts=left-mnum*60*60;System.out.println(h+" "+ m+" "+lefts+" "+left+" "+mnum*60*60+" "+mnum);}static void method2(){Scanner sc=new Scanner(System.in);
// long s=sc.nextInt();long s= 1618708103123L /1000;//秒//转换为只剩今天s=s%(24*60*60);//记住！这是当天的秒long hour=s/3600;//小时s=s%3600;long minutes=s/60;s=s%60;long second=s;System.out.println(String.format("%02d:%02d:%02d",hour,minutes,second));//首先字符串格式化用string.format(" ",v1),%d代表整型，%f浮点数，%s字符串}
}
q7最小砝码
【问题描述】
你有一架天平。现在你要设计一套砝码，使得利用这些砝码可以称出任意
小于等于 N NN 的正整数重量。
那么这套砝码最少需要包含多少个砝码？
注意砝码可以放在天平两边。
【输入格式】
输入包含一个正整数 N NN。
【输出格式】
输出一个整数代表答案。
【样例输入】
7
【样例输出】
3
【样例说明】
3 个砝码重量是 1、4、6，可以称出 1 至 7 的所有重量。
1 = 1；
2 = 6 − 4 (天平一边放 6，另一边放 4)；
3 = 4 − 1；
4 = 4；
5 = 6 − 1；
6 = 6；
7 = 1 + 6；
少于 3 个砝码不可能称出 1 至 7 的所有重量。
【评测用例规模与约定】
对于所有评测用例，1 ≤ N NN ≤ 1000000000
import java.util.Scanner;public class Main {public static void main(String[] args) {Scanner sc = new Scanner(System.in);long n = sc.nextLong();sc.close();int i, ans;for (i = 1, ans = 1; ans < n; i++) {ans += Math.pow(3, i);}System.out.println(i);}
}
/** 1个砝码最大称到1* * 2个砝码最大称到4
*
* 3个砝码最大称到13* 推出公式为：新一级的砝码最大称重=上一级砝码上限 × 3 + 1*/import java.util.*;
public class Main { public static void main(String[] args) { Scanner sc = new Scanner(System.in); //Scanner输入 int N = sc.nextInt(); //变量N接收输入需要称重的重量sc.close(); //关闭输入int sum = 0; //变量sum用来计算可计算的重量for(int i = 1; i > 0; i++) { //一直循环sum = sum * 3 + 1; //用公式让sum往后推if(N <= sum) { //如果sum大于等于N时则为可称出N的重量i为砝码个数System.out.println(i); //输出需要最少的砝码个数break; //退出}}
}
q8杨辉三角
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ivBuJpZ9-1651583658472)(蓝桥杯真题2017-2021Img/image-20220406203934117.png)]
package q2021;import java.util.*;public class q杨辉三角 {static int n;public static void main(String[] args) {Scanner sc = new Scanner(System.in);n = sc.nextInt();int[][] a = new int[n][n];dp();}static void dp() {Set<Integer> set=new HashSet<>();int [][] dp=new int[100][100];dp[0][1]=1;int ans=1;set.add(1);for (int k = 1; k <1000 ; k++) {for (int l = 1; l <=k+1 ; l++) {dp[k][l]=dp[k-1][l]+dp[k-1][l-1];ans++;if (set.contains(n)){System.out.println(ans-1);return;}if (!set.contains(dp[k][l])){set.add(dp[k][l]);}}}}
}
q9双向排序
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mD9V32XV-1651583658473)(蓝桥杯真题2017-2021Img/image-20220406204430470.png)]
q10括号序列
给定一个括号序列，要求尽可能少地添加若干括号使得括号序列变得合法，当添加完成后，会产生不同的添加结果，请问有多少种本质不同的添加结果。
两个结果是本质不同的是指存在某个位置一个结果是左括号，而另一个是右括号。
例如，对于括号序列 ((()，只需要添加两个括号就能让其合法，有以下几种不同的添加结果：()()()、()(())、(())()、(()()) 和 ((()))。
【输入格式】
输入一行包含一个字符串 s ss，表示给定的括号序列，序列中只有左括号和
右括号。
【输出格式】
输出一个整数表示答案，答案可能很大，请输出答案除以 1000000007 10000000071000000007 (即
1 0 9 + 7 10^9 + 710
9
+7) 的余数。
【样例输入】
((()
【样例输出】
5
【评测用例规模与约定】
对于 40 % 40%40% 的评测用例，∣ s ∣ ≤ 200 |s| ≤ 200∣s∣≤200 。
对于所有评测用例，1 ≤ ∣ s ∣ ≤ 5000 1 ≤ |s| ≤ 50001≤∣s∣≤5000 。
:08:23
package q2021;import sun.net.www.http.Hurryable;import java.util.Scanner;public class qF时间显示 {public static void main(String[] args) {method2();}static void method(){long s = 1618708103123l / 1000;//秒long h = s / 3600;//消失long x=h;int hnum = 0;while (h > 24) {h -= 24;hnum++;}long left=s-hnum*24*3600;//剩下的秒long m=left/60;long y=m;int mnum=0;while (y>60){y-=60;mnum++;}long lefts=left-mnum*60*60;System.out.println(h+" "+ m+" "+lefts+" "+left+" "+mnum*60*60+" "+mnum);}static void method2(){Scanner sc=new Scanner(System.in);
// long s=sc.nextInt();long s= 1618708103123L /1000;//秒//转换为只剩今天s=s%(24*60*60);//记住！这是当天的秒long hour=s/3600;//小时s=s%3600;long minutes=s/60;s=s%60;long second=s;System.out.println(String.format("%02d:%02d:%02d",hour,minutes,second));//首先字符串格式化用string.format(" ",v1),%d代表整型，%f浮点数，%s字符串}
}
q7最小砝码
【问题描述】
你有一架天平。现在你要设计一套砝码，使得利用这些砝码可以称出任意
小于等于 N NN 的正整数重量。
那么这套砝码最少需要包含多少个砝码？
注意砝码可以放在天平两边。
【输入格式】
输入包含一个正整数 N NN。
【输出格式】
输出一个整数代表答案。
【样例输入】
7
【样例输出】
3
【样例说明】
3 个砝码重量是 1、4、6，可以称出 1 至 7 的所有重量。
1 = 1；
2 = 6 − 4 (天平一边放 6，另一边放 4)；
3 = 4 − 1；
4 = 4；
5 = 6 − 1；
6 = 6；
7 = 1 + 6；
少于 3 个砝码不可能称出 1 至 7 的所有重量。
【评测用例规模与约定】
对于所有评测用例，1 ≤ N NN ≤ 1000000000
import java.util.Scanner;public class Main {public static void main(String[] args) {Scanner sc = new Scanner(System.in);long n = sc.nextLong();sc.close();int i, ans;for (i = 1, ans = 1; ans < n; i++) {ans += Math.pow(3, i);}System.out.println(i);}
}
/** 1个砝码最大称到1* * 2个砝码最大称到4
*
* 3个砝码最大称到13* 推出公式为：新一级的砝码最大称重=上一级砝码上限 × 3 + 1*/import java.util.*;
public class Main { public static void main(String[] args) { Scanner sc = new Scanner(System.in); //Scanner输入 int N = sc.nextInt(); //变量N接收输入需要称重的重量sc.close(); //关闭输入int sum = 0; //变量sum用来计算可计算的重量for(int i = 1; i > 0; i++) { //一直循环sum = sum * 3 + 1; //用公式让sum往后推if(N <= sum) { //如果sum大于等于N时则为可称出N的重量i为砝码个数System.out.println(i); //输出需要最少的砝码个数break; //退出}}
}
q8杨辉三角
[外链图片转存中…(img-ivBuJpZ9-1651583658472)]
package q2021;import java.util.*;public class q杨辉三角 {static int n;public static void main(String[] args) {Scanner sc = new Scanner(System.in);n = sc.nextInt();int[][] a = new int[n][n];dp();}static void dp() {Set<Integer> set=new HashSet<>();int [][] dp=new int[100][100];dp[0][1]=1;int ans=1;set.add(1);for (int k = 1; k <1000 ; k++) {for (int l = 1; l <=k+1 ; l++) {dp[k][l]=dp[k-1][l]+dp[k-1][l-1];ans++;if (set.contains(n)){System.out.println(ans-1);return;}if (!set.contains(dp[k][l])){set.add(dp[k][l]);}}}}
}
q9双向排序
[外链图片转存中…(img-mD9V32XV-1651583658473)]
q10括号序列
给定一个括号序列，要求尽可能少地添加若干括号使得括号序列变得合法，当添加完成后，会产生不同的添加结果，请问有多少种本质不同的添加结果。
两个结果是本质不同的是指存在某个位置一个结果是左括号，而另一个是右括号。
例如，对于括号序列 ((()，只需要添加两个括号就能让其合法，有以下几种不同的添加结果：()()()、()(())、(())()、(()()) 和 ((()))。
【输入格式】
输入一行包含一个字符串 s ss，表示给定的括号序列，序列中只有左括号和
右括号。
【输出格式】
输出一个整数表示答案，答案可能很大，请输出答案除以 1000000007 10000000071000000007 (即
1 0 9 + 7 10^9 + 710
9
+7) 的余数。
【样例输入】
((()
【样例输出】
5
【评测用例规模与约定】
对于 40 % 40%40% 的评测用例，∣ s ∣ ≤ 200 |s| ≤ 200∣s∣≤200 。
对于所有评测用例，1 ≤ ∣ s ∣ ≤ 5000 1 ≤ |s| ≤ 50001≤∣s∣≤5000 。
蓝桥杯真题2017-2021相关推荐
- 【蓝桥杯真题】2021年蓝桥杯省赛A组题目解析+代码（python组）
2021年蓝桥杯省赛A组题解(python组) 来自微信公众号:算法梦工厂,二维码见文末. 欢迎加入蓝桥杯备赛群:768245918,获取往届试题,测试数据,算法课程等相关资源. A:卡片 答案:31 ...
- 蓝桥杯python省赛冲刺篇2——常用算法的详细解析及对应蓝桥杯真题：打表模拟法、递推递归法、枚举法、贪心算法、差分与前缀和
注意:加了题目链接 目录 注意:加了题目链接 一.打表模拟法 介绍 1. 算式问题 题目描述 解析与代码演示 2. 求值 题目描述 解析与代码演示 3. 既约分数 题目描述 解析与代码演示 4. 天干 ...
- 2016年第七届蓝桥杯真题解析JavaC组
相关题目: 2016年第七届蓝桥杯真题解析JavaB组 2016年第七届蓝桥杯真题解析JavaC组 2017年第八届蓝桥杯真题解析JavaB组 2017年第八届蓝桥杯真题解析JavaC组 2018年第 ...
- python解答蓝桥杯真题2 猜年龄 美国数学家维纳(N.Wiener)智力早熟，11岁就上了大学。他曾在19351936年应邀来中国清华大学讲学。。。
python解答蓝桥杯真题2 猜年龄 美国数学家维纳(N.Wiener)智力早熟,11岁就上了大学.他曾在1935~1936年应邀来中国清华大学讲学... 问题描述 全排列模板: 美国数学家维纳(N. ...
- 第五届蓝桥杯真题解析【JavaC组】
第五届蓝桥杯真题解析[JavaC组] 业精于勤,荒于嬉:行成于思,毁于随.--韩愈 文章目录 ***第五届蓝桥杯真题解析[JavaC组]*** 前言 A:猜年龄 B:等额本金 C:猜字母 D:大衍数列 ...
- 【蓝桥杯真题】16天冲刺 Python
距离比赛很快了,希望和我一起准备的PY党能更加熟练的掌握Python! 1.距离和(模拟赛填空题) 问题描述: 两个字母之间的距离定义为它们在字母表中位置的距离.例如 A和 C 的距离为 2,L 和 ...
- 蓝桥杯真题：三羊献瑞
蓝桥杯真题:三羊献瑞 观查下面的加法算式: 其中相同的汉字代表相同的数字,不同的汉字代表不同的数字. 请你填写"三羊献瑞"所代表的4位数字(答案唯一),不要填写任何多余内容. 分析 ...
- # 2014年蓝桥杯真题CC++B组
2014年蓝桥杯真题C/C++B组 1.啤酒和饮料 题目描述 啤酒每罐2.3元,饮料每罐1.9元,小明买了若干啤酒和饮料,一共花了82.3元. 我们还知道她买的啤酒比饮料的数量多,请你计算他买了几罐啤 ...
- 第十届蓝桥杯c语言试题,第十届蓝桥杯真题编程题1-7解析(高级组).pdf
scratch 少儿编程第十届蓝桥杯真题 7 大家好 ~今天我们来讲解 scratch 蓝桥杯第十届编程大题的第七道题. 同样,这道题也是非常有难度的一道题.一起来看一下吧 解析: 女孩的程序 1.在 ...
最新文章
- 业余快速学习虚幻引擎教程
- 收藏 | 75道常见AI面试题助你清扫知识盲点（附解析）
- Sublime text 2/3 [Decode error - output not utf-8] 完美解决方法
- centos7重新加载服务的命令_阿粉手把手教你在 CentOS7 下搭建 Jenkins
- mysql 数据迁移_mysql实验--不同字符集数据库迁移步骤演示
- linux基础—课堂随笔_03 SHELL脚本编程基础
- P2756,ssl2601-飞行员配对问题【网络流24题,最大匹配,dinic】
- MSN-LDL论文修改20211027RBY
- numpy.arange语法，作用以及举例
- python 写csv scrapy_Python神技能 | 使用爬虫获取汽车之家全车型数据
- UE4 在游戏中使用Slate
- Android漫游记(1)---内存映射镜像(memory maps)
- crontab计划任务的失败记录查找
- SharePoint 2010开发实例精选——通过客户端对象模型删除页面上的Web部件
- 使用 Clang Tools —— ClangFormat
- WebService 服务 转
- 计算机颜色的概念,颜色空间
- 学习笔记︱Nvidia DIGITS网页版深度学习框架——深度学习版SPSS
- SVG和G语言的混合显示引擎
- 贪心算法基础之活动时间安排（一）安排 51nod 贪心教程