蓝桥杯-Java|第八届蓝桥杯大赛个人赛省赛（软件类）真题-Java语言B组 java|职场和发展|经验分享|ecl

目录
1.购物单
2.纸牌三角形
3.承压计算
4.魔方状态
5.取数位
6.最大公共子串
7.日期问题
8.包子凑数
9.分巧克力
10.k倍区间
1.购物单

小明刚刚找到工作，老板人很好，只是老板夫人很爱购物。老板忙的时候经常让小明帮忙到商场代为购物。小明很厌烦，但又不好推辞。
这不，XX大促销又来了！老板夫人开出了长长的购物单，都是有打折优惠的。
小明也有个怪癖，不到万不得已，从不刷卡，直接现金搞定。
现在小明很心烦，请你帮他计算一下，需要从取款机上取多少现金，才能搞定这次购物。
取款机只能提供100元面额的纸币。小明想尽可能少取些现金，够用就行了。
你的任务是计算出，小明最少需要取多少现金。
以下是让人头疼的购物单，为了保护隐私，物品名称被隐藏了。
-----------------
****180.9088折
****10.2565折
****56.149折
****104.659折
****100.3088折
****297.15半价
****26.7565折
****130.62半价
****240.2858折
****270.628折
****115.8788折
****247.3495折
****73.219折
****101.00半价
****79.54半价
****278.447折
****199.26半价
****12.979折
****166.3078折
****125.5058折
****84.989折
****113.3568折
****166.57半价
****42.569折
****81.9095折
****131.788折
****255.8978折
****109.179折
****146.6968折
****139.3365折
****141.1678折
****154.748折
****59.428折
****85.4468折
****293.7088折
****261.7965折
****11.3088折
****268.2758折
****128.2988折
****251.038折
****208.3975折
****128.8875折
****62.069折
****225.8775折
****12.8975折
****34.2875折
****62.1658折
****129.12半价
****218.37半价
****289.698折
--------------------
需要说明的是，88折指的是按标价的88%计算，而8折是按80%计算，余者类推。
特别地，半价是按50%计算。
请提交小明要从取款机上提取的金额，单位是元。
答案是一个整数，类似4300的样子，结尾必然是00，不要填写任何多余的内容。

【解析】直接将购物单复制到eclipse里然后选中购物单内容按Ctrl+F 将****换成+，将“折”换成空格，“半折”换成*0.5，然后自己在数字前加*和小数点

public class Main { public static void main(String[] args) { double sum =180.90*0.88 +10.25*0.65 +56.14*0.9 +104.65*0.9 +100.30*0.88 +297.15*0.5 +26.75*0.65 +130.62*0.5 +240.28*0.58 +270.62*0.8 +115.87*0.88 +247.34*0.95 +73.21*0.9 +101.00*0.5 +79.54*0.5 +278.44*0.7 +199.26*0.5 +12.97*0.9 +166.30*0.78 +125.50*0.58 +84.98*0.9 +113.35*0.68 +166.57*0.5 +42.56*0.9 +81.90*0.95 +131.78*0.8 +255.89*0.78 +109.17*0.9 +146.69*0.68 +139.33*0.65 +141.16*0.78 +154.74*0.8 +59.42*0.8 +85.44*0.68 +293.70*0.88 +261.79*0.65 +11.30*0.88 +268.27*0.58 +128.29*0.88 +251.03*0.8 +208.39*0.75 +128.88*0.75 +62.06*0.9 +225.87*0.75 +12.89*0.75 +34.28*0.75 +62.16*0.58 +129.12*0.5 +218.37*0.5 +289.69*0.8; System.out.println(sum); } }

答案：5200
2.纸牌三角形（全排列）

A,2,3,4,5,6,7,8,9 共9张纸牌排成一个正三角形（A按1计算）。要求每个边的和相等。
下图就是一种排法（如有对齐问题，参看p1.png）。

文章图片

这样的排法可能会有很多。
如果考虑旋转、镜像后相同的算同一种，一共有多少种不同的排法呢？
请你计算并提交该数字。
注意：需要提交的是一个整数，不要提交任何多余内容。

文章图片

【解析】可以用数组表示，分别表示为三条边arr[1]+arr[2]+arr[3]+arr[4]
arr[7]+arr[8]+arr[9]+arr[1]
arr[4]+arr[5]+arr[6]+arr[7]
判断是否相等，注意镜像和旋转
所以总和要/6

public class Main{ static int arr[]=new int[10]; static boolean vis[]=new boolean[10]; static int sum=0; static void dfs(int step) { if(step==10) { if(arr[1]+arr[2]+arr[3]+arr[4]==arr[4]+arr[5]+arr[6]+arr[7]&& arr[7]+arr[8]+arr[9]+arr[1]==arr[4]+arr[5]+arr[6]+arr[7]) sum++; return; } for(int i=1; i<=9; i++) { if(!vis[i]) { vis[i]=true; arr[step]=i; dfs(step+1); vis[i]=false; } } } public static void main(String[] args) { dfs(1); System.out.println(sum/6); //这里其实是count/3/2,除以3是排除了旋转，除以2是排除了镜像 } }

答案：144
3.承压计算

X星球的高科技实验室中整齐地堆放着某批珍贵金属原料。
每块金属原料的外形、尺寸完全一致，但重量不同。
金属材料被严格地堆放成金字塔形。

文章图片

假设每块原料的重量都十分精确地平均落在下方的两个金属块上，
最后，所有的金属块的重量都严格精确地平分落在最底层的电子秤上。
电子秤的计量单位很小，所以显示的数字很大。
工作人员发现，其中读数最小的电子秤的示数为：2086458231
请你推算出：读数最大的电子秤的示数为多少？
注意：需要提交的是一个整数，不要提交任何多余内容。

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

import java.util.Scanner; public class Main{ public static void main(String[] args) { Scanner sc = new Scanner(System.in); double[][] a = new double[30][30]; for (int i = 0; i < a.length-1; i++) { for (int j = 0; j <= i; j++) { a[i][j] = sc.nextInt(); } } for (int i = 1; i < a.length; i++) { for (int j = 0; j <= i; j++) { if(j>0){ a[i][j]+=(double)a[i-1][j-1]*1.0/2+(double)a[i-1][j]*1.0/2; }else if(j==0){ a[i][j]+=(double)a[i-1][j]*1.0/2; } } } for (int i = 0; i < a.length; i++) {//给最后一行排下序 for (int j = 0; j < a.length-1-i; j++) { if(a[29][j]>a[29][j+1]){ double t = a[29][j]; a[29][j] = a[29][j+1]; a[29][j+1] = t; } } } System.out.println((double)2086458231*1.0*a[29][29]/a[29][0]); } }

import java.util.*; public class Main{ static long[][] arr = new long[30][30]; 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; } //输入数据放入二维数组 for(int i = 0; i < 29; ++i) { for(int j = 0; j <=i; ++j) { long a=sc.nextLong(); arr[i][j]=a*factor; //每个数都乘以factor } } //自上而下处理a[i][j]*factor(2的30次方)-->除以2，计入a[i+1][j]和a[i+1][j+1] //循环处理第1~N-1行 for(int i = 0; i < 29; ++i) { for(int j = 0; j <= i; ++j) { long ha = arr[i][j]/2; arr[i+1][j]+=ha; arr[i+1][j+1]+=ha; } } //对a[N-1]这一行进行排序，查看最小值与factor之间的倍数关系，决定最大值是多少 Arrays.sort(arr[29]); System.out.println(arr[29][0]); System.out.println(arr[29][29]); System.out.println(arr[29][29]/(arr[29][0]/2086458231)); } }

答案：72665192664
4.魔方状态

二阶魔方就是只有2层的魔方，只由8个小块组成。
如图p1.png所示。
小明很淘气，他只喜欢3种颜色，所有把家里的二阶魔方重新涂了颜色，如下：
前面：橙色
右面：绿色
上面：黄色
左面：绿色
下面：橙色
后面：黄色
请你计算一下，这样的魔方被打乱后，一共有多少种不同的状态。
如果两个状态经过魔方的整体旋转后，各个面的颜色都一致，则认为是同一状态。
请提交表示状态数的整数，不要填写任何多余内容或说明文字。

文章图片

import java.util.HashSet; import java.util.Set; public class Main { 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 HashSet all_state = new HashSet(); static intfront, 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]); //拷贝到tail u(q[tail]); //上层顺时针旋转 if (try_insert(q[tail])) { tail++; //扩展队列 } memcpy(q[tail], q[front]); //拷贝到tail r(q[tail]); //右层顺时针旋转 if (try_insert(q[tail])) { tail++; //扩展队列 } memcpy(q[tail], q[front]); //拷贝到tail f(q[tail]); //前顺时针旋转 if (try_insert(q[tail])) { tail++; //扩展队列 } front++; //弹出队首 //cout << front << " " << tail << endl; } System.out.println(front); } public static void main(String[] args) { solve(); } }

答案：229878
5.取数位求1个整数的第k位数字有很多种方法。
以下的方法就是一种。

public 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){ if(len(x)-k==0) return x%10; return ______________________; //填空 }public static void main(String[] args) { int x = 23513; //System.out.println(len(x)); System.out.println(f(x,3)); } }

对于题目中的测试数据，应该打印5。

请仔细分析源码，并补充划线部分所缺少的代码。

注意：只提交缺失的代码，不要填写任何已有内容或说明性的文字。

public 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){ 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)); } }

答案：f(x/10,k)
6.最大公共子串最大公共子串长度问题就是：
求两个串的所有子串中能够匹配上的最大长度是多少。
比如：“abcdkkk” 和 “baabcdadabc”，
可以找到的最长的公共子串是"abcd",所以最大公共子串长度为4。
下面的程序是采用矩阵法进行求解的，这对串的规模不大的情况还是比较有效的解法。
请分析该解法的思路，并补全划线部分缺失的代码。

public 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]; int max = 0; for (int i = 1; i < a.length; i++) { for (int j = 1; j < a[i].length; j++) { if (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) { int n = f("abcdkkk", "baabcdadabc"); System.out.println(n); } }

public 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]; int max = 0; for (int i = 1; i < a.length; i++) { 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); } }

答案：a[i - 1][j - 1] + 1
7.日期问题小明正在整理一批历史文献。这些历史文献中出现了很多日期。小明知道这些日期都在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，否则按无效代码处理。

import java.util.Arrays; import java.util.Calendar; import java.util.Scanner; public class Main{ static boolean leap(int l) { if((l%4==0&&l%100!=0)||l%400==0) return true; return false; } public static void main(String[] args) { Scanner in =new Scanner( System.in); String s=in.nextLine(); int a=Integer.parseInt(s.substring(0, 2)); int b=Integer.parseInt(s.substring(3,5)); int c=Integer.parseInt(s.substring(6,8)); int[]z=new int[6]; z[0]=(2000+a)*10000+b*100+c; z[1]=(1900+a)*10000+b*100+c; z[2]=(2000+c)*10000+a*100+b; z[3]=(2000+c)*10000+b*100+a; z[4]=(1900+c)*10000+a*100+b; z[5]=(1900+c)*10000+b*100+a; int daycount[]={31,29,31,30,31,30,31,31,30,31,30,31}; Arrays.sort(z); for(int i=0; i<6; i++) { int year=z[i]/10000; int month=z[i]%10000/100; int day=z[i]%100; if(year<1960||year>2059)continue; if(month<1||month>12)continue; if(leap(year))daycount[1]=29; else daycount[1]=28; if(day<1||day>daycount[month-1])continue; StringBuffer string=new StringBuffer(z[i]+""); string.insert(4, '-'); string.insert(7, '-'); System.out.println(string); } } }

8.包子凑数小明几乎每天早晨都会在一家包子铺吃早餐。他发现这家包子铺有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
【解析】若每个抽屉的容量不互质，则不能表达的数有INF，若互质，则利用完全背包的思路解决，具体参看代码注释。

import java.util.Scanner; public class Main{ public static void main(String[] args) { Scanner sc =new Scanner(System.in); int num = sc.nextInt(); int bao[] =new int[num]; int dp[]=new int[100*100+5]; for(int i=0; i



 
9.分巧克力 儿童节那天有 K位小朋友到小明家做客。小明拿出了珍藏的巧克力招待小朋友们。

 小明一共有 N块巧克力，其中第 i 块是 Hi×Wi的方格组成的长方形。

 为了公平起见，小明需要从这 N块巧克力中切出 K块巧克力分给小朋友们。切出的巧克力需要满足：

 1.形状是正方形，边长是整数
 2.大小相同

 例如一块 6×5的巧克力可以切出 6 块 2×2 的巧克力或者 2 块 3×3的巧克力。

 当然小朋友们都希望得到的巧克力尽可能大，你能帮小明计算出最大的边长是多少么？
 输入

 第一行包含两个整数 N和 K以下 N行每行包含两个整数 Hi 和 Wi输入保证每位小朋友至少能获得一块 1×1的巧克力。
 输出

 输出切出的正方形巧克力最大可能的边长

 数据范围

 1≤N,K≤105

 1≤Hi,Wi≤105
 输入样例：

 2 10
 6 5
 5 6
 输出样例：

 2

 
import java.util.Scanner;

public class Main{
public static void main(String[] args) {
Scanner input=new Scanner(System.in);

int N=input.nextInt();

int K=input.nextInt();

int l=1;

int r=100001;

int ck[][]=new int[N][2];

//N块分给十个人
for(int i=0;
i=K){
return 1;

}
}
return 0;

}
}


 
10.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

 
import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
int n, k;

long ans = 0;

Scanner sc = new Scanner(System.in);

n=sc.nextInt();

k=sc.nextInt();

int [] sum = new int [100001];

int [] num = new int [100001];

int [] cnt = new int [100001];

for(int i = 1;
 i <= n;
 i++){
num[i] = sc.nextInt();

sum[i] = (sum[i-1] + num[i])%k;

ans += cnt[sum[i]];

cnt[sum[i]]++;

}
long a = ans +(long)cnt[0];

System.out.println(a);

	}
}


 【蓝桥杯-Java|第八届蓝桥杯大赛个人赛省赛（软件类）真题-Java语言B组】


		  	

    
    




    
    
    


推荐阅读

           
                  
              
                  dota2国服启动项设置代码 
                
                   
                
              
            

                  
              
                  什么是公共英语三级 公共英语三级的解释 
                
                   
                
              
            

                  
              
                  宁波征兵网2020年报名时间 2023年宁波征兵报名应征须知一览 
                
                   
                
              
            

                  
              
                  玉米有虫要喷什么农药，有虫还能吃吗 
                
                   
                
              
            

                  
              
                  电脑开机就显示结束进程怎么办 
                
                   
                
              
            

                  
              
                  夏季多吃苦味食物祛暑消炎健脾胃 
                
                   
                
              
            

                  
              
                  小心机|又一波回忆杀！Reno6 Pro+柯南限定版真机上手，处处都有小心机 
                
                   
                
              
            

                  
              
                  怎么鉴别石斛霍山石斛真假 
                
                   
                
              
            

                  
              
                  魔女之泉4全剧情通关攻略汇总 通关攻略 
                
                   
                
              
            

                  
              
                  济南石崮寨玉符河畔2023植树节活动 济南石崮寨森林公园 
                
                   
                
              
            

                  
              
                  牛仔休闲裤配什么外套女 牛仔休闲裤配什么外套 
                
                   
                
              
            

                  
              
                  糖醋洋姜 
                
                   
                
              
            

                  
              
                  简评这7款iphone机型 iphone机型参数对比 
                
                   
                
              
            

                  
              
                  汽车防火墙隔音降噪怎么做 
                
                   
                
              
            

                  
              
                  超级推荐系统出价智能上限，这样修改很合适！ 
                
                   
                
              
            

                  
              
                  千元以内的航拍机能不能用？ 
                
                   
                
              
            

                  
              
                  关于SpringBoot创建存储令牌的媒介类和过滤器的问题 
                
                   
                
              
            

                  
              
                  离别，其实就是一瞬间 
                
                   
                
              
            

                  
              
                  防卫行为和正当防卫的区别 一般什么行为是正当防卫？ 
                
                   
                
              
            

                  
              
                  美菱冰箱报e1故障 
                
                   
                
              
            

          

java|Java蓝桥杯——九宫幻方 
 图文详解 Spring AOP，看完必懂。。 
 Java之路|为什么MySQL不推荐使用uuid作为主键（） 
 项目实战|SpringBoot个人博客从无到有项目搭建——实战综合介绍 
 程序员|官方都不推荐（为什么MySQL不推荐使用uuid作为主键？究竟有什么坏处） 
 数据库|为啥不能用uuid做MySQL的主键！（） 
 LeetCode编程题解法汇总|力扣解法汇总258-各位相加 
 redis|2021-11-13 记录（Java连接远程Redis的报错信息和解决办法） 
 安全|深入分析H2数据库控制台中无需身份验证的RCE漏洞