2022年十三届蓝桥杯省赛JavaB组，1-8题解全通过100%，省一国二自解
目录
试题A：星期计算
试题B：山
试题C：字符统计
试题D：最少刷题数
试题E：求阶乘
试题F：最大子矩阵
试题G：数组切分
试题H：回忆迷宫
试题A：星期计算
// 十三届省赛第一题，星期计算
public static void f1() {
// 不算结果取模即可，缓存无限大
int res = (int) (Math.pow(20, 22) % 7 + 6);
System.out.println(res);
}试题B：山
// 十三届省赛第二题，山：暴力
public static void f2() {
long res = 0;
for (int i = 2022; i <= 2022222022; i++) {
if (check1(i + "")) {
// System.out.println(i);
res++;
}
}
System.out.println(res);
}
public static boolean check1(String str) {
int len = str.length();
// 前大半不减
for (int i = 0; i < len - len / 2 - 1; i++) {
if (str.charAt(i) > str.charAt(i + 1)) {
return false;
}
}
// 后小半回文
for (int i = len - len / 2; i < len; i++) {
if (str.charAt(i) != str.charAt(len - i - 1)) {
return false;
}
}
return true;
} // 方法二，优化：按位数分类，注意头尾
public static void f3() {
long res = 0;
for (int i = 21; i <= 99; i++) {
if (check2(i + "")) {
res++;
}
}
for (int i = 111; i <= 9999; i++) {
if (check2(i + "")) {
res += 2;
}
}
for (int i = 11111; i <= 99999; i++) {
if (check2(i + "")) {
// System.out.println(i);
res++;
}
}
for (int i = 11111; i <= 20221; i++) {
if (check2(i + "")) {
res++;
}
}
System.out.println(res);
}
public static boolean check2(String str) {
char[] chs = str.toCharArray();
Arrays.sort(chs);
if (Arrays.equals(chs, str.toCharArray())) {
return true;
}
return false;
}试题C：字符统计
// 十三届省赛第三题，字符统计
public static void f4(String str) {
// Z的ascll=90
int[] arr = new int[100];
for (int i = 0; i < str.length(); i++) {
arr[str.charAt(i)]++;
}
int max = 0;
for (int i = 0; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
for (int i = 0; i < arr.length; i++) {
if (arr[i] == max) {
// 顺序拿出即为有序
System.out.print((char) i);
}
}
}试题D：最少刷题数
// 十三届省赛第四题，最少刷题数（排序后，查找一遍，遍历计算所有结果）
public static void f5(List list, List sist) {
int num = sist.get(sist.size() / 2);
int pre = sist.indexOf(num);
int next = sist.size() - 1 - sist.lastIndexOf(num);
for (int i = 0; i < list.size(); i++) {
int temp = list.get(i);
//大的比小的少
if(next 试题E：求阶乘
//十三届省赛第五题，求阶乘：二分查找阶乘的值
public static long f6(long k) {
//先确定边界
long l=-1,r;
long p=1;//外拓指针
while (f7(p)=k) {
r=m;
}else {
l=m;
}
}
if(f7(r)==k) {
return r;
}else {
//处理没有的情况，如k=5
return -1;
}
}
//欧几里得找5的因子即为0的个数（处理没有的情况，如sum=5）
public static long f7(long m) {
long n=m;
long sum=0;
//欧几里得公式
while (n>0) {
sum+=n/5;
n/=5;
}
return sum;
} 试题F：最大子矩阵
// 具有列最大最小值的变形一维数组变形一维求最大子数组（优化：sum预算+跳列遍历）
public static int f3(int lim, int[][] arr) {
int sum = 0;// 变形子数组的最大元素个数（0表示单列不满足）
flag: for (int i = 0; i < arr[0].length; i++) {
int smin = arr[0][i], smax = arr[1][i];
if (smax - smin <= lim) {
sum = Math.max(1, sum);
} else {
continue flag;
}
int sminy = i, smaxy = i;// 记录左极端值的列
for (int j = i + 1; j < arr[0].length; j++) {
// System.out.println(i+" "+j);
if (arr[1][j] > smax) {
if (arr[1][j] - smin > lim) {
i = Math.min(sminy, smaxy);// 跳列遍历
continue flag;
}
smax = arr[1][j];
smaxy = j;
}
if (arr[0][j] < smin) {
if (smax - arr[0][j] > lim) {
i = Math.min(sminy, smaxy);// 跳列遍历
continue flag;
}
smin = arr[0][j];
sminy = j;
}
if (j - i + 1 > sum) {// 此子数组的元素个数
sum = j - i + 1;
}
if (sum >= arr[0].length - i) {// 预算此子数组最大个数，是否还需要遍历
break flag;
}
}
}
return sum;
}
// 十三届省赛第六题，最大子矩阵：二维化一维（枚举行组合）
public static int f4(int lim, int[][] table) {
int sum = 1;
int[][] arr = new int[2][table[0].length];// 具有列最大最小值的变形一维数组
for (int i = 0; i < table.length; i++) {
for (int j = i; j < table.length; j++) {
for (int k = 0; k < arr[0].length; k++) {// 组合为具有列最大最小值的变形一维数组
arr[0][k] = table[i][k];// 初始化
arr[1][k] = table[i][k];// 初始化
for (int t = i; t <= j; t++) {
arr[0][k] = Math.min(table[t][k], arr[0][k]);
arr[1][k] = Math.max(table[t][k], arr[1][k]);
}
}
int mid = f3(lim, arr);
// System.out.println(Arrays.toString(arr[0]));
// System.out.println(Arrays.toString(arr[1]));
// System.out.println(mid);
sum = Math.max(mid * (j - i + 1), sum);
Arrays.fill(arr[0], 0);// 清除
Arrays.fill(arr[1], 0);// 清除
}
}
return sum;
}试题G：数组切分
// //十三届省赛第七题，数组切分：动规递推
// 2 1 5 4 3
// 2 :arr[0]=1 =1
// 2 1 :arr[1]=arr[0]+1 =2
// 2 1 5 :arr[2]=arr[1]+0+0 =2
// 2 1 5 4 :arr[3]=arr[2]+arr[1]+0+0 =4
// 2 1 5 4 3:arr[4]=arr[3]+arr[2]+arr[1]+0+1=9
public static long f5(int[] arr) {
long[] dp = new long[arr.length];
dp[0] = 1;// 初始化第一个
for (int i = 1; i < dp.length; i++) {
int min = arr[i], max = arr[i];// 初始化
for (int j = i; j >= 0; j--) {// 后往前求dp[i]
min = Math.min(min, arr[j]);// 维持最小值
max = Math.max(max, arr[j]);// 维持最大值
if (j != 0) {
if (max - min == i - j) {// 核心：最大减最小等于长度则为连续如：(2 1 3:3-1=2-0)
dp[i] += dp[j - 1] % 1000000007;// 处理MOD
}
} else {// 判断整体是否满足
if (max - min == i - j) {// 核心：最大减最小等于长度则为连续如：(2 1 3:3-1=2-0)
dp[i] += 1;
}
}
}
}
// System.out.println(Arrays.toString(dp));
return dp[arr.length - 1] % 1000000007;// 最后再处理MOD
}试题H：回忆迷宫
// 十三届省赛第八题，回忆迷宫：先填墙（路边+内空）再挖路
static Character[][] table = new Character[300][300];// 取150,150为中心开始
public static void f7(char[] arr) {
int nx = 150, ny = 150, mx = 150, my = 150;// 最小最大的坐标，输出用
for (Character[] cs : table) {
Arrays.fill(cs, ' ');// 初始化
}
int[][] empty = new int[2][arr.length + 1];
int x = 150, y = 150;// 初始化位坐标
empty[0][0] = 150;// 初始化路的x坐标
empty[1][0] = 150;// 初始化路的y坐标
// 填墙
table[x - 1][y] = '*';// 初始化坐标墙
table[x + 1][y] = '*';// 初始化坐标墙
table[x][y - 1] = '*';// 初始化坐标墙
table[x][y + 1] = '*';// 初始化坐标墙
for (int i = 0; i < arr.length; i++) {
if (arr[i] == 'U') {// 上
x--;
} else if (arr[i] == 'D') {// 下
x++;
} else if (arr[i] == 'R') {// 右
y++;
} else if (arr[i] == 'L') {// 左
y--;
}
empty[0][i + 1] = x;// 记录路的x坐标
empty[1][i + 1] = y;// 记录路的y坐标
nx = Math.min(nx, x);// 维持最小x坐标
ny = Math.min(ny, y);// 维持最小y坐标
mx = Math.max(mx, x);// 维持最大x坐标
my = Math.max(my, y);// 维持最大y坐标
table[x - 1][y] = '*';// 填墙
table[x + 1][y] = '*';// 填墙
table[x][y - 1] = '*';// 填墙
table[x][y + 1] = '*';// 填墙
}
// for (int i = nx - 1; i <= mx + 1; i++) {
// for (int j = ny - 1; j <= my + 1; j++) {
// System.out.print(table[i][j]);
// }
// System.out.println();
// }
// System.out.println("==================");
// 填满中间（dfs深搜法，全面）
f8(nx-1,ny-1,mx+1,my+1);
// for (int i = nx - 1; i <= mx + 1; i++) {
// for (int j = ny - 1; j <= my + 1; j++) {
// System.out.print(table[i][j]);
// }
// System.out.println();
// }
// System.out.println("==================");
// 挖空
for (int i = 0; i < empty[0].length; i++) {
table[empty[0][i]][empty[1][i]] = ' ';
}
for (int i = nx - 1; i <= mx + 1; i++) {
for (int j = ny - 1; j <= my + 1; j++) {
System.out.print(table[i][j]);
}
System.out.println();
}
}
//填满中间，dfs深搜
static Character[][] copy=new Character[table.length][];
public static void f8(int nx,int ny,int mx,int my) {//左上右下坐标
for (int i = 0; i < copy.length; i++) {
copy[i]=table[i].clone();//复制表格
}
for (int i = nx; i <= mx; i++) {
for (int j = ny; j <= my; j++) {
if (copy[i][j] == ' ') {// 如果是一个被包围的空格则填墙
dfs(nx, ny, mx, my, i, j);
//填充原表格
if(flag) {
for (int k = 0; k < listx.size(); k++) {
table[listx.get(k)][listy.get(k)]='*';
}
}
//恢复
flag=true;
listx.clear();
listy.clear();
}
}
}
}
static boolean flag=true;
static List listx=new ArrayList();
static List listy=new ArrayList();
public static void dfs(int nx,int ny,int mx,int my,int x,int y) {//左上右下坐标
copy[x][y]='*';
listx.add(x);
listy.add(y);
if(x==nx||x==mx||y==ny||y==my) {
flag=false;
}
if(copy[x][y+1]==' '&&y+1<=my) {
dfs(nx, ny, mx, my, x, y+1);
}
if(copy[x][y-1]==' '&&y-1>=ny) {
dfs(nx, ny, mx, my, x, y-1);
}
if(copy[x+1][y]==' '&&x+1<=mx) {
dfs(nx, ny, mx, my, x+1, y);
}
if(copy[x-1][y]==' '&&x-1>=nx) {
dfs(nx, ny, mx, my, x-1, y);
}
} 