01.对角线上的最值【新生编程赛】

完整解题代码：

import java.util.Scanner;
import java.util.Collections;
import java.util.ArrayList;
// 1:无需package
// 2: 类名必须Main, 不可修改

public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        //在此输入您的代码...
        int N=scan.nextInt();
        int[][] arr=new int[N][N];


      for(int i=0;i<n;i++){
        for(int j=0;j<n;j++){
          arr[i][j]=scan.nextInt();
        }
      }

      ArrayList<Integer> e=new ArrayList<>();
      for(int i=0;i<n;i++){
        for(int j=0;j<n;j++){
          if(i==j || i+j==n-1){
            e.add(arr[i][j]);
          }
        }
      }
      
      int max=Collections.max(e);
      int min=Collections.min(e);

      System.out.println(max+" "+min);

      scan.close();
    }
  }

解题思路：

1.明确目标：本题需要我们找出 N×N 矩阵的主对角线和副对角线上所有元素的最大值和最小值，那么第一反应就是二维数组存数据，然后用各种各样的方法找最值。

2.读取输入：使用二维数组先读取矩阵的大小 N，再读取 N 行的矩阵元素。

3.收集元素：将输入数据转换为二维数组后，很容易想到用循环嵌套，遍历出主副对角线上的有限个元素。（元素位于主对角线时（行号i等于列号j）| |   副对角线（行号i + 列号j = N-1））

4.判断大小：因为是有限个元素，所以我们又考虑到利用动态数组ArrayList存储对角线上的元素，便于后续再次使用Collections.max()和Collections.min()方法进行最值计算。（详见“新生杯第一场03.设计师调度”）

5.输出结果：注意案例的输出最值之间有空格，因此我们使用增加空格“System.out.println(max+" "+min);”的输入方式。

涉及知识点：

1.二维数组：

• 创建和初始化二维数组

type[][] arrayName;


//或

type arrayName[][];

其中初始化可分为静态初始化和动态初始化，本体因为要读取题目动态的输入，我们使用动态初始化。

静态初始化：

// 规则二维数组（每行长度相同）
int[][] matrix1 = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

// 不规则二维数组（每行长度不同）
int[][] matrix2 = {
    {1, 2},    // 第0行长度为2
    {3},       // 第1行长度为1
    {4, 5, 6}  // 第2行长度为3
};

动态初始化：

int n = 3;
int[][] matrix = new int[n][];  // 先初始化外层数组（3行）
// 再分别初始化每行（列数可不同）
matrix[0] = new int[3];  // 第0行3列
matrix[1] = new int[2];  // 第1行2列
matrix[2] = new int[4];  // 第2行4列

// 简化写法（仅适用于规则数组，强制每行长度相同）
int[][] regularMatrix = new int[3][3];  // 3行3列的规则数组

• 访问与遍历

通过 “行索引” 和 “列索引” 访问元素（索引从 0 开始），遍历需使用双重循环。

（1）元素访问

int[][] matrix = {{1,2}, {3,4,5}};
int element = matrix[1][2];  // 访问第1行第2列的元素（值为5）
matrix[0][1] = 10;          // 修改第0行第1列的元素（改为10）

（2）遍历方式

• 普通 for 循环：适合需要索引的场景。

  for (int i = 0; i < matrix.length; i++) {  // 遍历行（matrix.length为行数）
      for (int j = 0; j < matrix[i].length; j++) {  // 遍历当前行的列（matrix[i].length为当前行的列数）
          System.out.print(matrix[i][j] + " ");
      }
      System.out.println();
  }
  

• 增强 for 循环：适合仅需元素值、无需索引的场景。

  for (int[] row : matrix) {  // 遍历每行（row是当前行的一维数组）
      for (int num : row) {   // 遍历当前行的每个元素
          System.out.print(num + " ");
      }
      System.out.println();
  }
  

（3）特点与适用场景

• 长度固定：一旦初始化，行数和每行的列数不可变（不能动态添加 / 删除行或列）。
• 内存高效：元素在内存中连续存储（内层数组是连续的），随机访问速度快（通过索引直接定位）。
• 适用场景：存储结构固定的二维数据（如矩阵运算、表格数据），例如该题代码中用int[][] arr存储 N×N 矩阵。

2.动态数组（ArrayList）：

• 核心概念：

定义：ArrayList是泛型类，需指定存储的元素类型（如 ArrayList<Integer> 存储整数），语法为 ArrayList<数据类型> 集合名 = new ArrayList<>()。

底层实现：内部维护一个Object[]类型的数组（elementData），当元素数量超过当前容量时，自动创建新数组并复制旧元素（扩容）。

• 初始化：

// 无参构造：初始容量为0（JDK1.8后），添加第一个元素时扩容为10
ArrayList<Integer> list1 = new ArrayList<>();

// 指定初始容量：减少扩容次数，适合已知大致元素数量的场景
ArrayList<String> list2 = new ArrayList<>(20);  // 初始容量为20

// 用其他集合初始化
ArrayList<Integer> list3 = new ArrayList<>(Arrays.asList(1, 2, 3));

• 常用方法：

方法	功能描述	示例
add(E e)	在末尾添加元素	list.add(5);
add(int index, E e)	在指定索引插入元素	list.add(1, 10); // 在索引 1 处插入 10
get(int index)	获取指定索引的元素	int num = list.get(2);
set(int index, E e)	修改指定索引的元素	list.set(0, 20); // 修改索引 0 为 20
remove(int index)	删除指定索引的元素，并返回被删除元素	int removed = list.remove(1);
size()	返回元素个数	int size = list.size();
isEmpty()	判断是否为空	boolean empty = list.isEmpty();
clear()	清空所有元素	list.clear();

3.二维数组与ArrayList的核心区别：

维度	二维数组（int[][]）	ArrayList
数据结构	数组的数组（支持二维索引）	动态扩容的一维数组（仅支持一维索引）
长度特性	长度固定（行数和列数不可变）	长度动态可变（自动扩容）
元素类型	可存储基本类型（如int）或引用类型	仅能存储引用类型（需用包装类，如Integer）
内存效率	更高（无额外扩容开销）	较低（可能存在未使用的容量，扩容需复制）
适用场景	固定结构的二维数据（如矩阵）	元素数量不确定的一维数据（如动态列表）

4.ArrayList中的最值操作（见过往博客如下）：

5.for-each循环（增强for循环）：

（因为啵猪第一次遇到该循环，遂单独列出学习一番。。。。。。。。）

增强for循环（也称为for-each循环）是Java从JDK 5开始引入的一种便捷循环语法，旨在简化对数组或集合类的迭代操作。

• 初始化for-each循环：

for(ElementType element: arrayName) 
{ //集合或数组的数据类型 变量名：集合名/数组名
	System.out.println(变量名)；
};

即：

for（数据类型 变量名：要遍历的数组）{
	输出语句（变量名）；
}

• 遍历数组：

遍历整型数组

增强for循环最常见的用途之一是遍历数组。它简化了传统for循环的语法，不需要维护索引变量。

int[] numbers = {10, 20, 30, 40, 50};

for (int number : numbers) {

        System.out.println(number);
}

输出：

10
20
30
40
50

遍历字符串数组

String[] fruits = {"Apple", "Banana", "Cherry"};

for (String fruit : fruits) {

    System.out.println(fruit);
}

输出：

Apple
Banana
Cherry

遍历二维数组

• 增强 for 循环可以嵌套使用，方便遍历多维数组。
• 二维数组本质上还是一个数组，只不过它的每个元素都是一个一维的数组。因此对二维数组进行遍历时，要嵌套遍历两次。

int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

for (int[] row : matrix) {
    for (int element : row) {
        System.out.print(element + " ");
    }
    System.out.println();
}

输出：

1 2 3 
4 5 6 
7 8 9 

• 注意事项：

无法修改集合结构：在增强for循环中，不能直接对集合进行add或remove操作，否则会抛出ConcurrentModificationException。

无法访问索引：增强for循环中无法直接获取元素的索引。如果需要索引，需使用传统for循环。

02.加工等级之和【新生编程赛】

完整解题代码1：

import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改
public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int N = scan.nextInt(); // 读取组件数量
        int[] arr = new int[N]; // 存储加工等级数组

        // 读取所有加工等级
        for (int i = 0; i < N; i++) {
            arr[i] = scan.nextInt();
        }

        long sum = 0; // 存储结果总和（用long避免溢出）

        // 遍历每个加工等级，判断是否满足条件
        for (int num : arr) {
            // 情况1：等级为1时，num-1=0（不存在），直接加入总和
            if (num == 1) {
                sum += num;
                continue;
            }

            // 情况2：等级>1时，遍历原始数组检查是否存在num-1
            boolean ifLevel = false; // 标记是否存在num-1
            for (int n : arr) {
                if (n == num - 1) {
                    ifLevel = true;
                    break; // 找到后立即退出内层循环，减少无效操作
                }
            }

            // 如果不存在num-1，加入总和
            if (!ifLevel) {
                sum += num;
            }
        }

        System.out.println(sum);
        scan.close();
    }
}

解题思路1：

1.明确目标：题目看起来有点绕，但实际上就是要我们统计每个加工等级的出现次数，但这个次数需要判断是否满足条件，最终累加符合条件的等级。

2.遍历判断：先遍历判断情况1：等级为1时，num-1=0（不存在），直接加入总和；

然后再次遍历判断关键的情况2：等级>1时，遍历原始数组检查是否存在num-1。

（等于说是多次遍历所有的加工等级，有超时风险，但在我看来是最直接的思路了）

3.统计输出：将最后的sum统计输出。

提交检测：

完整解题代码2：

import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改

public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        //在此输入您的代码...
        int N=scan.nextInt();
        int[] arr=new int[N];

     
        for(int i=0;i<N;i++){
          arr[i]=scan.nextInt();  
        }

        int[] count=new int[200000];
        for(int i=0;i<arr.length;i++){
          int num=arr[i];
          count[num]++;
        }

        long sum=0;
        for(int i=0;i<arr.length;i++){
          int num=arr[i];
          if(num==1 || count[num-1]==0){
            sum+=num;
          }
        }
        System.out.println(sum);
        scan.close();
    }
}

解题思路2：

1.明确目标：题目看起来有点绕，但实际上就是要我们统计每个加工等级的出现次数，但这个次数需要判断是否满足条件，最终累加符合条件的等级。

（核心注意点：因为N和Aᵢ范围很大，有超时的风险，因此我们要选择引入数组count(提高效率的做法)，而不是直接让代码每次都重新遍历整个原始数组去检查。）

2.引入计数数组统计：即第一遍循环遍历先统计所有的等级。我们先用数组读取两行输入，并用一个数组count记录每个加工等级在原始数组中出现的次数。

• count的下标代表 “加工等级”（比如count[5]对应等级 5）。
• count的元素值代表 “该等级出现的次数”（比如count[5] = 3表示等级 5 出现了 3 次）。

举例说明：

假设原始数组arr = [2, 3, 1, 3, 5]（即 5 个组件的等级分别为 2、3、1、3、5）。

遍历arr时，每遇到一个等级num，就给count[num]加 1：

• 遇到2 → count[2] = 1
• 遇到3 → count[3] = 1
• 遇到1 → count[1] = 1
• 再遇到3 → count[3] = 2（第二次出现）
• 遇到5 → count[5] = 1

最终count数组中关键位置的值为：count[1] = 1，count[2] = 1，count[3] = 2，count[5] = 1（其他位置默认 0）。

3.增加求和逻辑：遍历原始数组中的每个等级num，判断其是否满足 “不存在等级为num-1的组件”，如果满足则加入总和sum。

分类讨论：

判断 “不存在等级为num-1” 的两种情况：

1. 当num = 1时：num-1 = 0，而题目中加工等级是正整数（至少为 1），因此等级 0 必然不存在。所以num=1一定满足条件，必须加入总和。

2. 当num > 1时：需检查count[num-1]的值：

   • 如果count[num-1] == 0：表示等级num-1在原始数组中从未出现过（即不存在），因此num满足条件，加入总和。
   • 如果count[num-1] > 0：表示等级num-1存在，因此num不满足条件，不加入总和。

进一步分析：

原始数组arr = [2, 3, 1, 3, 5]，count数组已统计完成。

遍历每个num：

• 第一个num=2：num>1，检查count[2-1] = count[1] = 1（等级 1 存在）→ 不满足条件，不加入sum。
• 第二个num=3：num>1，检查count[3-1] = count[2] = 1（等级 2 存在）→ 不满足条件，不加入sum。
• 第三个num=1：（跳过检查，等级0不存在），满足num==1 → 加入sum，sum = 1。
• 第四个num=3：同第二个num=3，不满足条件，不加入sum。
• 第五个num=5：num>1，检查count[5-1] = count[4] = 0（等级 4 不存在）→ 满足条件，加入sum，sum = 1 + 5 = 6。

最终sum=6，即满足条件的等级之和为 6。

提交检测：

                                                                                                 （时间上确实有所节省。。。。。）

03.蚀光之刃【新生编程赛】

完整解题代码：

public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        //在此输入您的代码...
        int A=scan.nextInt();
        int B=scan.nextInt();
        int C=scan.nextInt();
        int D=scan.nextInt();

        int num1;
        int num2;

        if(A==0){
          num1=Integer.MAX_VALUE;
        }else{
          num1=C/A;
        }

        if(B==0){
          num2=Integer.MAX_VALUE;
        }else{
          num2=D/B;
        }


        int max=Math.min(num1,num2);
        System.out.println(max);
        scan.close();
    }
}

解题思路：

1.明确目标：（题目又是一如既往的花里胡哨。。。）实则就是要求分别计算出两个玩意各自能支持锻造的最大剑数；然后按要求与配方取两者的最小值，即为最终能锻造的最大剑数。就有点类似于木桶效应只能取到短板。

2.判断星银矿：分类讨论：

• 若 A = 0（锻造不需要星银矿），则星银矿无限制，将 num1 设为 Integer.MAX_VALUE
• 若 A > 0，则 num1 = C / A（注意整数除法是自动向下取整，刚好能满足）。

3.判断龙之精粹：分类讨论同上：

• 若 B = 0（锻造不需要龙之精粹），则龙之精粹无限制，将 num2 设为 Integer.MAX_VALUE；
• 若 B > 0，则 num2 = D / B（整数除法，向下取整）。

4.输出结果：利用Math函数输出num1,num2之间的最小值即可。

05.机器人的行动轨迹【新生编程赛】

完整解题代码：

import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改

public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        //在此输入您的代码...
        Long N=scan.nextLong();
        if(N<=3){
          System.out.println(N);
        }else{
          System.out.println(5*(N-3)+3);
        }
        scan.close();
    }
}

解题思路：

。。。我就是列举出来找规律的，各位大佬对这题有更好的解法欢迎交流。。。

                                                                                       （ps:这该死的、丑陋的解答。。。）

04.代码纪元【新生编程赛】

（放到最后，这题没有做出来（反映出解决字符串问题较为薄弱的现状），遂借助AI学习）

样例输出：zaza

完整解题代码：

import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改

public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        String s = scan.next();
        // 步骤1：生成S的翻转串S'
        String revS = new StringBuilder(s).reverse().toString();
        // 步骤2：确定S和S'中的较大者maxSS（T只需大于maxSS，即可同时大于S和S'）
        String maxSS = s.compareTo(revS) > 0 ? s : revS;
        // 步骤3：生成比maxSS大的最小字符串
        String t = getSmallestBiggerString(maxSS);
        System.out.println(t);
        scan.close();
    }

  
    public static String getSmallestBiggerString(String s) {
        char[] chars = s.toCharArray();
        int n = chars.length;
        int i = n-1;

        // 从右向左找第一个不是'z'的字符（用于“原长度内修改”）
        while (i >= 0 && chars[i] == 'z') {
            i--;
        }

        // 情况1：原长度内的“下一个字符串”
        String case1;
        if (i < 0) {
            // 全为'z'，原长度内无法增大，只能在末尾加'a'
            case1 = s + "a";
        } else {
            // 找到的字符加1，右侧所有字符置为'a'（保证字典序最小）
            chars[i]++;
            for (int j = i + 1; j < n; j++) {
                chars[j] = 'a';
            }
            case1 = new String(chars);
        }

        // 情况2：原字符串末尾直接加'a'（长度+1）
        String case2 = s + "a";

        // 取两种情况中字典序较小的结果
        return case1.compareTo(case2) < 0 ? case1 : case2;
    }
}

解题思路：

1.明确目标：本题要求找到字典序严格大于字符串 S 及其翻转串 S' 的最小字符串 T。

而题目给出的字典序的比较规则我们可以翻译为 ：“逐位比较字符的 ASCII 码，若某一位字符不同，ASCII 小的字符串字典序更小；若所有位都相同，长度短的字典序更小”。(如题目样例，输入zaz,反转无影响，所以需要找到一个大于zaz的最小字符串，那就是+a，变成zaza。)

2.厘清步骤：

• 首先我得先生成翻转串 S'，即将 S 反转得到其关联的标识串。
• 然后我得比较S、S'这两个字符串，取字典序较大的那个（记为 maxSS）。然后让T 只需大于这个 maxSS，就能同时满足 “大于 S 且大于 S'”。
• 最后我就只需生成比 maxSS 大的最小字符串，但我需考虑 “原长度内修改” 和 “长度加 1” 两种情况，最终取字典序更小的结果。

因此根据以上步骤的加粗部分，我想要分成六步操作：

（1）生成翻转串 S'：想到利用 StringBuilder 的 reverse() 方法可以高效地将字符串反转。

（2）比较S、S'这两个字符串，取字典序较大：通过 String 的 compareTo 方法比较 S 和 S'：若 S.compareTo(revS) > 0，说明 S 字典序更大，maxSS = S；否则 maxSS = revS。

（3）生成比 maxSS 大的最小字符串:

要找到字典序最小的更大字符串，需遵循 “尽可能在右侧修改，且修改后右侧字符尽可能小（置为 'a'）” 的原则，分（4）、（5）两种情况处理：

（4）原长度内修改:

从右往左遍历，找到第一个不是 'z' 的字符：

• 若所有字符都是 'z'（如 S = "zzz"），则原长度内无法增大，需在末尾加 'a'（如 "zzza"）。
• 若找到非 'z' 的字符（如 S = "zaz"，字符 'a' 位于索引 1），则将该字符加 1（'a'→'b'），并将其右侧所有字符置为 'a'（保证字典序最小），得到 case1 = "zba"。

（5）长度加 1:

直接在 maxSS 末尾添加 'a'（如 S = "zaz" 时，case2 = "zaza"）。

（6）取字典序更小：

比较 case1 和 case2 的字典序，取更小的那个作为结果。

（思路清晰了，下面学习并分析AI的方法和语句使用）

涉及知识点：

1.反转字符串 StringBuilder 的 reverse()方法

reverse() 方法用于反转 StringBuilder 中字

 // 步骤1：生成S的翻转串S'
        String revS = new StringBuilder(s).reverse().toString();

符的顺序。这是一个非常直接且高效的操作，尤其适用于需要对字符串进行倒序处理的场景。

代码示例：

public class StringBuilder {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("Hello World");
        sb.reverse();
        System.out.println(sb); 
    }
}

输出:  dlroW olleH

题目中相关代码：

 // 步骤1：生成S的翻转串S'
        String revS = new StringBuilder(s).reverse().toString();

代码解读：

惊到了，这一行就完成了，遂继续追问AI，原来这种写法利用了方法链式调用的特性

并告诉我这种写法在逻辑和功能上与分开写是完全等价的，只是代码更简洁。

拆解如下：

• new StringBuilder(s)：创建一个包含字符串 s 的 StringBuilder 对象。
• .reverse()：对 StringBuilder 中的字符串进行反转（该方法返回 StringBuilder 自身，因此可以继续调用其他方法）。
• .toString()：将反转后的 StringBuilder 对象转换为 String 类型，最终赋值给 revS。

（这种链式调用是 Java 中常见的 “流式编程” 风格，能在保证可读性的前提下，让代码更简洁高效。）

2.比较字符串 String 的 compareTo ()方法

compareTo() 方法用于两种方式的比较：

• 字符串与对象进行比较。
• 按字典顺序比较两个字符串。

语法：

int compareTo(Object o)
 
或
 
int compareTo(String anotherString)

参数：

• o -- 要比较的对象。

• anotherString -- 要比较的字符串。

返回值：

返回值是整型，它是先比较对应字符的大小(ASCII码顺序)，如果第一个字符和参数的第一个字符不等，结束比较，返回他们之间的长度差值，如果第一个字符和参数的第一个字符相等，则以第二个字符和参数的第二个字符做比较，以此类推,直至比较的字符或被比较的字符有一方结束。

• 如果参数字符串等于此字符串，则返回值 0；
• 如果此字符串小于字符串参数，则返回一个小于 0 的值；
• 如果此字符串大于字符串参数，则返回一个大于 0 的值。

说明：

如果第一个字符和参数的第一个字符不等，结束比较，返回第一个字符的ASCII码差值。

如果第一个字符和参数的第一个字符相等，则以第二个字符和参数的第二个字符做比较，以此类推,直至不等为止，返回该字符的ASCII码差值。 如果两个字符串不一样长，可对应字符又完全一样，则返回两个字符串的长度差值。

代码实例：

public class Test {
 
    public static void main(String args[]) {
        String str1 = "Strings";
        String str2 = "Strings";
        String str3 = "Strings123";
 
        int result = str1.compareTo( str2 );
        System.out.println(result);
      
        result = str2.compareTo( str3 );
        System.out.println(result);
     
        result = str3.compareTo( str1 );
        System.out.println(result);
    }
}

以上程序执行结果为：

0

-3

-3

3.三目运算符 ? :—— 根据条件选值

同时注意到这段代码：

 // 步骤2：确定S和S'中的较大者maxSS（T只需大于maxSS，即可同时大于S和S'）
        String maxSS = s.compareTo(revS) > 0 ? s : revS;

经求助，使用了三目运算符

同时，祛魅一下，这等同于

String maxSS;
if (s.compareTo(revS) > 0) {
    // 如果s的字典序严格大于revS，maxSS取s
    maxSS = s;
} else {
    // 否则，maxSS取revS
    maxSS = revS;
}

解析三目运算符

三目运算符的格式是：

条件 ? 表达式1 : 表达式2

执行逻辑：先判断 “条件” 是否为true；

• 若为true，整个表达式的结果为表达式 1；
• 若为false，整个表达式的结果为表达式 2。

在本题中，String maxSS = s.compareTo(revS) > 0 ? s : revS;的每一部分含义如下：

1. 条件部分：s.compareTo(revS) > 0这里调用了String的compareTo方法，用于比较s和revS的字典序：

   • 若返回值>0，说明s的字典序严格大于revS；
   • 若返回值≤0，说明revS的字典序大于或等于s。

2. 表达式 1：s

       当 “条件为true” 时，maxSS被赋值为s。

     3.表达式 2：revS

  当 “条件为false” 时，maxSS被赋值为revS。

适用场景

三目运算符适合 **“条件判断后仅需简单赋值”** 的场景，能让代码更紧凑。但如果逻辑复杂（比如条件后需要执行多行代码），则建议还是用if-else，避免代码可读性下降。

4.代码封装

注意到该解题代码单独封装了生成 “比输入字符串大的最小字符串”的方法

• main方法的职责是 “统筹全局”：读取输入、生成翻转串、确定基准串maxSS、调用工具方法生成结果、输出答案。
• getSmallestBiggerString的职责是 “专注细节”：只负责生成 “比输入字符串大的最小字符串” 这一具体功能。

好处

便于复用和修改

如果未来需要多次使用 “生成比某个字符串大的最小字符串” 这个功能（比如题目扩展为处理多个字符串），封装成方法后可以直接调用（getSmallestBiggerString(s1)、getSmallestBiggerString(s2)），避免重复写相同的代码。

 // 步骤3：生成比maxSS大的最小字符串
        String t = getSmallestBiggerString(maxSS);
        System.out.println(t);

（在主函数直接调用输出结果）

可行性

在 Java 中，方法的核心作用就是 “封装一段独立的逻辑”。它可以接收输入参数（比如getSmallestBiggerString的参数String s），执行一系列操作后返回结果（比如返回生成的字符串case1或case2）。