数组 on Coder_Studio

BISHI66 子数列求积

Sat, 21 Feb 2026 22:12:44 +0000

思路

求解代码

private static final int MOD = 1000000007;

    /**
     * 主函数，处理输入输出并计算区间乘积
     *
     * @param args 命令行参数
     * @throws IOException 可能抛出IO异常
     */
    public static void main(String[] args) throws IOException {
        // 使用BufferedReader读取输入，PrintWriter输出结果
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取第一行输入，分割字符串并解析为整数n和q
        String[] str = br.readLine().trim().split("\\s+");
        int n = Integer.parseInt(str[0]);  // 数组长度
        int q = Integer.parseInt(str[1]);  // 查询次数


        // 创建前缀积数组，大小为n+1
        long[] preProduct = new long[n + 1];
        preProduct[0] = 1;  // 初始化前缀积的第一个元素为1
        // 读取数组元素并计算前缀积
        String[] numStr = br.readLine().trim().split("\\s+");
        for (int i = 1; i <= n; i++) {
            long val = Long.parseLong(numStr[i - 1]);  // 解析当前元素
            // 计算前缀积，并对MOD取模
            preProduct[i] = (preProduct[i - 1] * val) % MOD;
        }

        // 创建结果列表
        List<Long> res = new ArrayList<>();
        // 处理每个查询
        for (int i = 0; i < q; i++) {
            // 读取查询区间
            String[] strQ = br.readLine().split("\\s+");
            int l = Integer.parseInt(strQ[0]);  // 区间左端点
            int r = Integer.parseInt(strQ[1]);  // 区间右端点

            // 计算preProduct[l-1]的模逆元
            long invPreProduct = mypower(preProduct[l - 1], MOD - 2, MOD);
            // 计算区间[l,r]的乘积
            long ans = (preProduct[r] * invPreProduct) % MOD;
            res.add(ans);  // 将结果添加到列表中
        }

        // 使用StringBuilder构建输出字符串
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < res.size(); i++) {
            // 每个结果用空格分隔，最后一个结果后不加空格
            sb.append(res.get(i)).append(res.size() == n - 1 ? "" : " ");
        }


        // 输出结果并关闭流
        out.println(sb.toString());
        out.flush();
        out.close();
        br.close();
    }

    private static long mypower(long base, long exp, long mod) {

        long ans = 1 % mod;
        while (exp > 0) {

            if (exp % 2 == 1) {
                ans = (ans * base) % mod;
            }

            base = (base * base) % mod;
            exp /= 2;
        }

        return ans;
    }

BISHI63 计算阶乘

Thu, 19 Feb 2026 22:24:36 +0000

思路

求解代码

private static final int MOD = 1000000007;
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        int T = Integer.parseInt(br.readLine().trim());

        while (T-- > 0) {
            int n = Integer.parseInt(br.readLine().trim());

            long ans = 1;

            for(int i=1;i<=n;i++){
                ans = (ans*i)%MOD;
            }
            out.println(ans%MOD);
        }

        out.flush();
        out.close();
        br.close();
    }

BISHI61 小q的数列

Thu, 19 Feb 2026 21:23:17 +0000

思路

这道题本质上是要计算一个数字在二进制下“1”的个数，然后构造出另一个具有相同数量“1”但取值最小的数字。

求解代码

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        int T = Integer.parseInt(br.readLine().trim());

        while (T-- > 0) {
            String str = br.readLine();
            long n = Long.parseLong(str.trim());

            int c = Long.bitCount(n);
            long k = (1L << c) - 1;
            out.println(c + " " + k);
        }

        out.flush();
        out.close();
        br.close();
    }

BISHI59 阶乘末尾非零数字

Wed, 18 Feb 2026 21:33:04 +0000

思路

求解代码

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StreamTokenizer in = new StreamTokenizer(br);
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        in.nextToken();
        int n = (int)in.nval;

        out.println(find(n));
        out.flush();
        out.close();
        br.close();
    }

    private static int find(int n) {

        int n2 = 0, n5 = 0;
        int p = 1;

        for(int i=2;i<=n;i++){
            int tmp = i;
            while (tmp%5==0) {
                n5++;
                tmp/=5;
            }

            while (tmp%2==0) {
                n2++;
                tmp/=2;
            }

            p=(p*tmp)%10;
        }

        for(int i=0;i<n2-n5;i++){
            p=(p*2)%10;
        }
        return p;
    }

BISHI54货物堆放

Mon, 16 Feb 2026 22:00:34 +0000

流程图

求解代码

static class Goods{
        long w;
        long v;
        long c;

        Goods(long w,long v,long c){
            this.w = w;
            this.v = v;
            this.c = c;
        }
    }


    public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        int n = Integer.parseInt(br.readLine().trim());

        Goods[] goods = new Goods[n];
        long total = 0;
        for(int i=0;i<n;i++){
            String[] str = br.readLine().trim().split("\\s+");
            long w = Long.parseLong(str[0]);
            long v = Long.parseLong(str[1]);
            long c = Long.parseLong(str[2]);

            goods[i]=new Goods(w, v,c);
            total += v;
        }

        Arrays.sort(goods,(x,y)->Long.compare(x.c*y.w, y.c*x.w));

       // 总实际体积 = 初始体积总和 - sumCW，因此最大化sumCW是实现最小体积的关键
        long sumCW = 0;
        // 记录当前遍历商品的「上方总重量」，初始为0（第一个商品在最顶部，上方无重量）
        long upperWeight = 0;

        // 按"从上到下"的堆叠顺序遍历排序后的商品
        for (Goods g : goods) {
            // 计算当前商品的压缩贡献值：c_i × 上方总重量（W_i）
            // 这里必须先计算贡献，再更新上方重量（避免把当前商品算入自己的上方）
            sumCW += g.c * upperWeight;

            // 更新上方总重量：当前商品会成为后续商品的"上方重量"，需累加其重量
            upperWeight += g.w;
        }

        long res = total -sumCW;

        out.println(res);
        out.flush();
        out.close();
        br.close();
    }

【贪心】BISHI48 小红的整数配对

Sat, 14 Feb 2026 22:24:11 +0000

思路

求解代码

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
        String[] str = br.readLine().split("\\s+");
        int n = Integer.parseInt(str[0]);
        int k = Integer.parseInt(str[1]);

        String[] numStr = br.readLine().split("\\s+");
        int[] a = new int[n];

        for (int i = 0; i < n; i++) {
            a[i] = Integer.parseInt(numStr[i]);
        }

        Arrays.sort(a);

        long maxScore = 0;
        int i = n - 1;// 从末尾开始遍历
        // 从后往前贪心配对
        while (i >= 1) {
            if (a[i] - a[i - 1] <= k) {
                maxScore += (long) a[i] * a[i - 1];
                i -= 2;// 配对成功，跳过这两个元素
            } else {
                i -= 1;// 无法配对，只跳过当前元素
            }
        }

        out.println(maxScore);

        out.flush();
        out.close();
        br.close();
    }

【滑动窗口】BISHI47 交换到最大

Sat, 14 Feb 2026 21:39:48 +0000

思路

求解代码

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        int t = Integer.parseInt(br.readLine());

        while (t-- > 0) {

            String str = br.readLine();
            char[] s = str.toCharArray();
            int n = s.length;

            for (int i = 0; i < n; i++) {
                int max_val = s[i] - '0';
                int max_index = i;
                // 在窗口内寻找能产生最大价值的来源
                for (int j = i; j < Math.min(i + 10, n); j++) {
                    int cur_val = (s[j] - '0') - (j - i);
                    if (cur_val > max_val) {
                        max_val = cur_val;
                        max_index = j;
                    }
                }
                // 物理移动来源字符到当前位置i
                int tmp_index = max_index;
                while (tmp_index > i) {
                    char tmp_val = s[tmp_index];
                    s[tmp_index] = s[tmp_index - 1];
                    s[tmp_index - 1] = tmp_val;
                    tmp_index--;
                }
                // 将当前位置i的字符值更新为计算出的最优值
                s[i] = (char) (max_val + '0');
            }

            out.println(new String(s));
        }
        out.flush();
        out.close();
        br.close();
    }

BISHI46 小红的魔法药剂

Sat, 14 Feb 2026 20:09:43 +0000

流程图

求解代码

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        int n = Integer.parseInt(br.readLine());

        String[] str = br.readLine().split("\\s+");
        int[] redStr = new int[str.length];

        for (int i = 0; i < str.length; i++) {
            redStr[i] = Integer.parseInt(str[i]);
        }

        int sum = 0;
        // 遍历每种药剂
        for (int i = 0; i < n; i++) {
            // 读取合成第i种蓝色药剂所需的两种红色药剂的编号b和c
            String[] split = br.readLine().split("\\s+");
            int b = Integer.parseInt(split[0]);
            int c = Integer.parseInt(split[1]);

            // 计算合成第i种蓝色药剂的花费，即所需两种红色药剂价格之和
            int blue = redStr[b - 1] + redStr[c - 1];
            // 获取直接购买第i种红色药剂的花费
            int red = redStr[i];

            // 选择合成蓝色药剂和直接购买红色药剂两者花费较小的值，累加到总花费sum中
            sum += Math.min(blue, red);
        }

        out.println(sum);
        out.close();
        br.close();
    }

BISHI45 小红的矩阵染色

Fri, 13 Feb 2026 21:59:29 +0000

流程图

纵向遍历矩阵统计

贪心排序与 Score 计算

求解代码

public static void main(String[] args)throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        String[] str = br.readLine().split("\\s+");

        int n = Integer.parseInt(str[0]);
        int m = Integer.parseInt(str[1]);
        int k = Integer.parseInt(str[2]);

        char[][] matrix = new char[n][m];

        for(int i=0;i<n;i++){
            matrix[i]=br.readLine().toCharArray();
        }

        List<Integer> block = new ArrayList<>();
        for(int j = 0;j<m;j++){
            int current = 0;
            for(int i=0;i<n;i++){
                if(matrix[i][j]=='o'){
                    current++;
                }else{
                    if(current>=2){
                        block.add(current);
                    }
                    current = 0;
                }
            }

            if(current>=2){
                block.add(current);
            }
        }

        Collections.sort(block,Collections.reverseOrder());

        int score = 0;

        for(int len:block){
            if(k==0){
                break;
            }

            int cell = Math.min(k, len);
            if(cell>=2){
                score += cell-1;
            }
            k-=cell;
        }

        out.println(score);
        out.flush();
        out.close();
        br.close();
        
    }

题解 | 灵异背包？

Fri, 13 Feb 2026 00:18:28 +0000

求解代码

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        int n = Integer.parseInt(br.readLine());
        String[] str = br.readLine().split("\\s+");

        long sum = 0;
        int minOdd = Integer.MAX_VALUE;

        for (String s : str){
            int num = Integer.parseInt(s);

            sum += num;

            if((num&1)==1){
                minOdd=Math.min(num, minOdd);
            }
        }

        long res;

        if((sum&1)==0){
            res = sum;
        }else{
            if(minOdd!=Integer.MAX_VALUE){
                res = sum - minOdd;// 总和是奇数，需要减去最小的奇数（若存在）
            }else{
                res = 0;// 没有奇数，只能选空背包
            }
        }
        out.println(res);
        out.flush();
        out.close();
        br.close();

    }

BISHI43 讨厌鬼进货

Fri, 13 Feb 2026 00:00:30 +0000

求解代码

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
        String[] s = br.readLine().split("\\s+");

        int n = Integer.parseInt(s[0]);
        long x = Long.parseLong(s[1]);

        String[] strA = br.readLine().split("\\s+");
        String[] strB = br.readLine().split("\\s+");

        long sum = 0;

        for (int i = 0; i < n; i++) {
            int a = Integer.parseInt(strA[i]);
            int b = Integer.parseInt(strB[i]);

            sum += Math.min(a, b); // 每种货物选A/B中更便宜的
        }
        long res = Math.min(x, sum);// 比较单独买总和与网购成本
        out.println(res);
        out.flush();
        out.close();
        br.close();

    }

BISHI42 余数求和

Thu, 12 Feb 2026 23:18:07 +0000

求解思路

由于对任意正整数$k, i$，有$k \mod i = k - i \times \lfloor \frac{k}{i} \rfloor$

$$\sum_{i=1}^n (k \mod i) = \sum_{i=1}^n \left( k - i \times \lfloor \frac{k}{i} \rfloor \right) = n \times k - \sum_{i=1}^{\min(n,k)} \left( i \times \lfloor \frac{k}{i} \rfloor \right)$$

求解代码

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
        String[] str = br.readLine().split("\\s+");

        long n = Long.parseLong(str[0]);
        long k = Long.parseLong(str[1]);

        long total = n * k; // 原表达式的第一部分
        long m = Math.min(n, k); // 只需要计算到min(n,k)
        long i = 1;

        while (i <= m) {
            long v = k / i;
            long j = Math.min(k / v, m); // 当前块的右边界
            // 计算i到j的和：(i+j)*(j-i+1)/2，再乘以v
            total -= v * (i + j) * (j - i + 1) / 2;
            i = j + 1; // 跳到下一个块
        }
        out.println(total);
        out.flush();
        out.close();
        br.close();

    }

BISHI41 【模板】整除分块

Thu, 12 Feb 2026 22:28:33 +0000

求解思路

当 $n=5$ 时：

$i=1 \rightarrow \lfloor 5/1 \rfloor = 5$
$i=2 \rightarrow \lfloor 5/2 \rfloor = 2$
$i=3 \rightarrow \lfloor 5/3 \rfloor = 1$
$i=4 \rightarrow \lfloor 5/4 \rfloor = 1$
$i=5 \rightarrow \lfloor 5/5 \rfloor = 1$

可以看到：$i=3,4,5$ 对应的 $\lfloor 5/i \rfloor$ 都是 1，这一段可以批量计算。

对于当前的 $i$，设 $v = \lfloor \frac{n}{i} \rfloor$，则最大的 $j$ 满足 $\lfloor \frac{n}{j} \rfloor = v$ 是： $j = \left\lfloor \frac{n}{v} \right\rfloor$。

因此，我们可以按“值相同的区间”分块，每个区间的贡献是 $v \times (j - i + 1)$，然后直接跳到 $j+1$ 继续计算。

求解代码

public static void main(String[] args) throws IOException {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer in = new StringTokenizer(br.readLine());

        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        long n = Long.parseLong(in.nextToken());

        long res = 0;

        long i = 1;

        while (i <= n) {
            long v = n / i; // 当前块的取值
            long j = n / v; // 当前块的右边界
            res += v * (j - i + 1); // 计算当前块的贡献
            i = j + 1; // 跳到下一个块的起点
        }

        out.println(res);
        out.flush();
        out.close();
        br.close();
    }

BISHI40数组取精

Thu, 12 Feb 2026 21:12:37 +0000

求解思路

1.先分别计算序列A和B的总和sumA 和sumB

2.将所有元素按照$a_i +b_i$从大到小排序

3.依次选取排序后的元素，累加子集的A和、B和，直到同时满足超过总和的一半

4.输出选取的元素的原始索引

求解代码

static class Element {
        int a; // 对应数组A的元素值
        int b; // 对应数组B的元素值
        int index;// 该元素在原数组中的索引（从1开始）

        // 构造方法：初始化a、b、index
        Element(int a, int b, int index) {
            this.a = a;
            this.b = b;
            this.index = index;
        }
    }

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        int n = Integer.parseInt(br.readLine());

        String[] strA = br.readLine().split(" ");
        String[] strB = br.readLine().split(" ");

        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        List<Element> elements = new ArrayList<>();

        long sumA = 0, sumB = 0;

        for (int i = 0; i < n; i++) {
            int a = Integer.parseInt(strA[i]); // 把strA的字符串转成整数
            int b = Integer.parseInt(strB[i]); // 把strB的字符串转成整数
            elements.add(new Element(a, b, i + 1)); // 封装成Element，索引从1开始
            sumA += a; // 累加A的总和
            sumB += b; // 累加B的总和
        }

        Collections.sort(elements, (e1, e2) -> {
            long s1 = (long) e1.a + e1.b;
            long s2 = (long) e2.a + e2.b;

            return Long.compare(s2, s1);// 按a+b从大到小排序
        });

        List<Integer> res = new ArrayList<>();
        long currentA = 0, currentB = 0;

        for (Element e : elements) {
            res.add(e.index); // 把当前元素的索引加入结果
            currentA += e.a; // 累加子集的A和
            currentB += e.b; // 累加子集的B和
            // 检查是否满足条件：子集和超过总和的一半
            if (currentA > sumA / 2 && currentB > sumB / 2) {
                break; // 满足条件则停止选取
            }
        }
        out.println(res.size());

        for (int i = 0; i < res.size(); i++) {
            out.print(res.get(i)+(i == res.size() - 1 ? "" : " "));
        }

        out.flush();
        out.close();
        br.close();
    }

BISHI35 【模板】巴什博弈

Tue, 10 Feb 2026 22:52:34 +0000

求解代码

 public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StreamTokenizer in = new StreamTokenizer(br);

        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
        in.nextToken();
        int t = (int) in.nval;
        for (int i = 0; i < t; i++) {
            in.nextToken();
            int n = (int) in.nval;
             in.nextToken();
            int m = (int) in.nval; 
            
            if(n%(m+1)==0){
                out.println("NO");
            }else{
                out.println("YES");
            }
            
        }

        out.flush();
        out.close();
        br.close();
    }

小贴士

若 n = k*(m+1)（即 n%(m+1)==0）：无论先手取 x 个（1≤x≤m），后手都可以取 (m+1)-x 个，最终后手总能取到最后一个物品 ➡️ 先手必败；
若 n ≠ k*(m+1)：先手可以先取 n%(m+1) 个，让剩余物品数为 k*(m+1)，此时后手陷入必败局面➡️先手必胜。

BISHI34 甜蜜的博弈

Tue, 10 Feb 2026 21:59:29 +0000

求解代码

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StreamTokenizer in = new StreamTokenizer(br);

        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
        in.nextToken();
        int t = (int) in.nval;
        for (int i = 0; i < t; i++) {
            in.nextToken();
            int n = (int) in.nval;
            // 判断规则：n=3、n=6，或 n≥9 且为奇数 → Bob 赢，否则 Alice 赢；
            if (n == 3 || n == 6 || (n >= 9 && (n % 2 == 1))) {
                out.println("Bob");
            } else {
                out.println("Alice");
            }
        }

        out.flush();
        out.close();
        br.close();
    }

BISHI29 小红的排列构造①

Mon, 09 Feb 2026 21:12:30 +0000

求解代码

 public static void main(String[] args) throws IOException {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        StreamTokenizer in = new StreamTokenizer(br);

        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        in.nextToken();
        int n = (int) in.nval;

        int[] arr = new int[n];

        if(n<=2){
            out.println(-1);
        }else{
            arr[0]=3;// 第一个元素固定为3
            for (int i = 1; i < n; i++) {
                arr[i]=i+1;//从第2个元素开始，值为「索引+1」
            }
            arr[2]=1;// 第三个元素强制改为1

            for(int i=0;i<n;i++){
                out.print(arr[i]+(i == n - 1 ? "" : " "));
            }
        }



        out.flush();
        out.close();
        br.close();
    }

两种方式构造数独

Mon, 09 Feb 2026 20:25:17 +0000

循环矩阵

 public static void main(String[] args) throws IOException {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        StreamTokenizer in = new StreamTokenizer(br);

        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        in.nextToken();
        int n = (int) in.nval;

        in.nextToken();
        int k = (int) in.nval;
        
        int[] firstRow = new int[n];
        int q = k/n;
        int r = k%n;

        /**
         * sum(firstRow) = r*(q+1) + (n-r)*q = n*q + r = k
         */
        for(int i=0;i<n;i++){
            if(i<r){
                firstRow[i]=q+1;
            }else{
                firstRow[i]=q;
            }
        }

        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                //第i行是第一行循环左移 i 位的结果
                //加n可避免j-i为负数时取模出错
                out.print(firstRow[(j-i+n)%n]+(j==n-1?"":" "));
            }
            out.println();
        }

        out.flush();
        out.close();
        br.close();
    }

方法2-YYDS（有一点马叉虫）

public static void main(String[] args) throws IOException {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        StreamTokenizer in = new StreamTokenizer(br);

        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        in.nextToken();
        int n = (int) in.nval;

        in.nextToken();
        int k = (int) in.nval;

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (i == j) {
                    out.print(k + (j == n - 1 ? "" : " "));
                } else {
                    out.print(0 + (j == n - 1 ? "" : " "));
                }
            }
            out.println();
        }

        out.flush();
        out.close();
        br.close();
    }

【曼哈顿距离】BISHI25 最大 FST 距离

Sun, 08 Feb 2026 23:57:10 +0000

求解代码

public static void main(String[] args) throws IOException {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        StreamTokenizer in = new StreamTokenizer(br);

        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        in.nextToken();
        int n = (int) in.nval;

        long[] a = new long[n];

        for (int i = 0; i < n; i++) {
            in.nextToken();
            a[i] = (long) in.nval;
        }

        long maxU = Long.MIN_VALUE;
        long minU = Long.MAX_VALUE;
        long maxV = Long.MIN_VALUE;
        long minV = Long.MAX_VALUE;

        for (long i = 0; i < n; i++) {
            // 计算当前位置的索引（从1开始，而非0）
            long idx = i + 1;
            long val = a[(int) i];

            // 计算u值：位置索引的平方 + 数值的平方
            long u = idx * idx + val * val;
            // 计算v值：位置索引的平方 - 数值的平方
            long v = idx * idx - val * val;

            maxU = Math.max(maxU, u);
            minU = Math.min(minU, u);

            maxV = Math.max(maxV, v);
            minV = Math.min(minV, v);

        }
        long dist = Math.max(maxU - minU, maxV - minV);
        
        out.println(dist);

        out.flush();
        out.close();
        br.close();
    }

BISHI18 多项式输出

Sat, 07 Feb 2026 20:50:20 +0000

求解代码

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StreamTokenizer in = new StreamTokenizer(br);
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        in.nextToken();
        int n = (int) in.nval;

        int[] a = new int[n + 1];

        for (int i = n; i >= 0; i--) {
            in.nextToken();
            a[i] = (int) in.nval;
        }

        for (int i = n; i >= 0; i--) { // 从最高次到0次遍历，按数学顺序输出
            // 跳过系数为0的项（比如x²项系数为0，就不输出这一项）
            if (a[i] == 0) {
                continue;
            }

            // 处理符号
            if (i == n) { // 最高次项
                if (a[i] < 0) { // 最高次项为负，输出"-"
                    out.print("-");
                }
            } else { // 非最高次项
                if (a[i] < 0) { // 负数输出"-"
                    out.print("-");
                } else { // 正数必须输出"+"
                    out.print("+");
                }
            }

            // 处理系数
            int val = Math.abs(a[i]);
            // 系数绝对值≠1 或 是常数项（i=0），才输出数字；否则不输出
            if (val != 1 || i == 0) {
                out.print(val);
            }

            // 处理x的次数格式
            if (i == 1) { // 一次项：输出"x"
                out.print("x");
            } else if (i > 1) { // 高于1次项：输出"x^次数"
                out.print("x^" + i);
            }

        }

        out.flush();
        out.close();
        br.close();

    }

BISHI13 九倍平方数

Fri, 06 Feb 2026 21:28:19 +0000

问题分析

由于每个数字的修改规则是仅x²<10时可改，并且只有2和3的修改会改变“各位和的模9值”，其他数字修改后模9值是不变的。

假设初始各位和为sum，模9得rest = sum %9；

如果rest=0，直接返回true；

否则，需要通过修改k个2和m个3，让增量总和k*2 + m*6和 (9 - rest) %9相等。

这样一来，问题就转化为判断是否存在k（≤count2）、m（≤count3）使得(k*2 + m*6) %9 == target。

另外，

由于2*9=18,所以改9个2和改0个2的效果是一样的，因此k的取值最多为min(count2,8)；

由于6*3=18，所以改3个3和改0个3的效果也是一样的，因此m的取值最多为min(count3,2)；

求解代码

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class Main {

    public static boolean isGoodNum(String s){
        long sum = 0;
        int count2= 0;
        int count3=0;
        for(char c:s.toCharArray()){
            int num = c-'0';
            sum += num;

            if(num == 2){
                count2++;
            }else if(num ==3){
                count3++;
            }
        }

        int rest  = (int)(sum%9);

        if(rest==0){
            return true;
        }

        int target = (9-rest)%9;

        for(int i=0;i<=Math.min(count2,8);i++){
            for(int j=0;j<=Math.min(count3,2);j++){
                if((i*2+j*6)%9==target){
                    return true;
                }
            }
        }
        return false;
    }
   public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer in = new StringTokenizer(br.readLine());
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        
        int t = Integer.parseInt(in.nextToken());


        for(int i=0;i<t;i++){
            in = new StringTokenizer(br.readLine());
            String s = in.nextToken();
            if(isGoodNum(s)){
                out.println("YES");
            }else{
                out.println("NO");
            }
        }
        out.flush();
        out.close();
        br.close();
   }
}

【BISHI11】变幻莫测

Thu, 05 Feb 2026 23:36:21 +0000

求解代码

public static void main(String[] args)throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer in = new StringTokenizer(br.readLine());
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        long x = Long.parseLong(in.nextToken());
        long y = Long.parseLong(in.nextToken());

        if(x==y){
            out.println(0);
        }else if(y==0){
            // 第二个数为0，1步操作即可满足条件
            out.println(1);
        }else if(x==0){
            // 第一个数为0，2步操作即可满足条件
            out.println(2);
        }else if(x+y==0){
             // 两数互为相反数（y = -x），3步操作满足条件
            out.println(3);
        }else{
            out.println(-1);
        }

        out.flush();
        out.close();
        br.close();
   }

【BISHI9】田忌赛马

Thu, 05 Feb 2026 22:02:59 +0000

求解代码

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        int[] v = new int[3];
        int[] a = new int[3];

        StringTokenizer in = new StringTokenizer(br.readLine());
       
        for (int i = 0; i < 3; i++) {
            v[i] = Integer.parseInt(in.nextToken());
        }

//读取第二行
        in= new StringTokenizer(br.readLine());
        for (int i = 0; i < 3; i++) {
            a[i] = Integer.parseInt(in.nextToken());
        }

        Arrays.sort(v);
        Arrays.sort(a);

        if (a[2] > v[1] && a[1] > v[0]) {
            out.println("Yes");
        } else {
            out.println("No");
        }
        out.flush();
        out.close();
        br.close();
    }

总持续时间可被 60 整除的歌曲

Mon, 02 Feb 2026 21:39:04 +0000

求解代码

public int numPairsDivisibleBy60(int[] time) {
            // 创建长度为60的数组，下标对应余数0~59，存储对应余数出现的次数
            int[] arr = new int[60];

            int ans = 0;

            for (int t : time) {
                // 计算当前时长对60取余，将数值范围压缩到 0~59
                t %= 60;

                //查找能和当前余数t配对的余数的出现次数，累加到结果中
                ans += arr[(60 - t) % 60];

                // 将当前余数的计数+1，存入数组，供后续元素配对使用
                arr[t]++;
            }

            return ans;
        }

数组列表中的最大距离

Mon, 02 Feb 2026 20:29:23 +0000

求解代码

        public int maxDistance(List<List<Integer>> arrays) {
            // 初始化最小值为第一个数组的第一个元素（升序数组的最小值）
            int min = arrays.get(0).get(0);
            // 初始化最大值为第一个数组的最后一个元素（升序数组的最大值）
            int max = arrays.get(0).get(arrays.get(0).size() - 1);

            int res = 0;

            for (int i = 1; i < arrays.size(); i++) {
                // 计算当前数组的最大值 与 之前所有数组最小值 的差，更新最大距离
                res = Math.max(res, Math.abs(arrays.get(i).get(arrays.get(i).size() - 1) - min));
                // 计算之前所有数组最大值 与 当前数组最小值 的差，更新最大距离
                res = Math.max(res, Math.abs(max - arrays.get(i).get(0)));
                // 更新全局最小值
                min = Math.min(min, arrays.get(i).get(0));
                // 更新全局最大值
                max = Math.max(max, arrays.get(i).get(arrays.get(i).size() - 1));
            }
            return res;
        }

【前缀和】LCR_013_二维区域和检索-矩阵不可变

Sat, 31 Jan 2026 21:33:54 +0000

求解代码

    private int[][] preSum;

    public NumMatrix(int[][] matrix) {
        int m = matrix.length;
        int n = matrix[0].length;

        if(m==0||n==0){
            return;
        }
        preSum = new int[m+1][n+1];


        for(int i=1;i<=m;i++){
            for(int j=1;j<=n;j++){
                preSum[i][j]=preSum[i-1][j]+preSum[i][j-1]+matrix[i-1][j-1]-preSum[i-1][j-1];
            }
        }
    }
    
    public int sumRegion(int row1, int col1, int row2, int col2) {
        return preSum[row2+1][col2+1]-preSum[row2+1][col1]-preSum[row1][col2+1]+preSum[row1][col1];
    }

小贴士

预处理：preSum[i][j] = 上 + 左 + 当前元素 - 重复部分；

查询：区域和 = 整体和 - 左侧和 - 上方和 + 重复和。

【总和拆分 + 双变量遍历】LCR_012_寻找数组的中心下标

Sat, 31 Jan 2026 20:28:31 +0000

求解代码

public int pivotIndex(int[] nums) {

        int leftSum = 0;
        int rightSum = 0;

        // 遍历数组，把所有元素的和存入 rightSum，
        // 此时 rightSum 是 “整个数组的和”
        for (int num : nums) {
            rightSum += num;
        }

        for (int i = 0; i < nums.length; i++) {
            // 从总和中减去当前元素，rightSum 变为“下标i右侧所有元素的和”
            rightSum -= nums[i];

            // 判断“右侧和”是否等于“左侧和”，相等则当前i就是中心下标
            if (rightSum == leftSum) {
                return i;
            }

            // 将当前元素加入左侧和，为下一个下标的判断做准备
            leftSum += nums[i];
        }
        return -1;
    }

【前缀和+哈希】LCR_011_连续数组

Sat, 31 Jan 2026 19:56:13 +0000

求解代码

public int findMaxLength(int[] nums) {

        int ans = 0;
        int sum = 0;

        HashMap<Integer,Integer> hMap = new HashMap<>();

        hMap.put(0, -1);

        for(int i=0;i<nums.length;i++){
            sum+=(nums[i]==0?-1:1);

            if(hMap.containsKey(sum)){
                ans=Math.max(ans, i-hMap.get(sum));
            }else{
                hMap.put(sum, i);
            }
        }
        return ans;
    }

小贴士

这道题关键在于把0转为-1，1保持1，将问题转化为“找和为0的最长子数组”。

解释一下这行代码：

`1`	`map.put(0, -1);`

假设从数组起始位置（下标 0）到下标 i 的前缀和为 0，说明 [0, i] 区间内 0 和 1 数量相等，此时子数组长度就是 i - (-1) = i + 1

【前缀和+哈希】LCR 010. 和为 K 的子数组

Fri, 30 Jan 2026 22:30:00 +0000

求解代码

public int subarraySum(int[] nums, int k) {
        // 哈希表：key=前缀和，value=该前缀和出现的次数
        HashMap<Integer, Integer> map = new HashMap<>();

        int sum = 0; // 记录当前遍历到的前缀和
        int ans = 0;

        // 初始化前缀和为0的情况出现了1次
        map.put(0, 1);

        for (int i = 0; i < nums.length; i++) {
            sum += nums[i]; // 累加当前元素，得到当前前缀和sum

            // 查找是否存在sum - k，存在则累加次数到结果
            if (map.containsKey(sum - k)) {
                ans += map.get(sum - k);
            }

            // 将当前前缀和存入哈希表：若已存在则次数+1，否则设为1
            map.put(sum, map.getOrDefault(sum, 0) + 1);
        }
        return ans;
    }

【滑动窗口】LCR 009. 乘积小于 K 的子数组

Fri, 30 Jan 2026 21:50:40 +0000

求解代码

public int numSubarrayProductLessThanK(int[] nums, int k) {

        int cur = 1;

        int left = 0;

        int right = 0;

        int res = 0;

        // 每次循环都在考虑：以 right 为右边界的所有满足条件的子数组
        while (right < nums.length) {

            // 把 nums[right] 包含进来
            cur *= nums[right];

            // 调整左边界，保证窗口乘积 < k
            while (left <= right && cur >= k) {
                // 从窗口中移除 nums[left]
                cur /= nums[left];

                // 左边界右移，缩小窗口
                left++;
            }

            // 计算以 right 为右边界的满足条件的子数组个数

            res += (right - left + 1);

            // 右指针右移，准备处理下一个右边界
            right++;
        }

        return res;
    }

小贴士

关键在于以 right 为结尾的、乘积 < k 的子数组有right - left + 1 个

【前缀和+滑动窗口】LCR 008. 长度最小的子数组

Fri, 30 Jan 2026 21:16:06 +0000

求解代码

public static int minSubArrayLen(int target, int[] nums) {
    // 获取原数组长度
    int n = nums.length;
    
    int[] preSum = new int[n + 1];
    
    preSum[0] = 0;
    
    for (int i = 1; i <= n; i++) {
        preSum[i] = preSum[i - 1] + nums[i - 1];
    }
    
    int left = 0;  
    int right = 1;  

    int ans = Integer.MAX_VALUE;

    while (right < preSum.length) {
        
        
        // 当前窗口的和 >= target
        if (preSum[right] - preSum[left] >= target) {
            
            // 更新最小长度
            ans = Math.min(right - left, ans);
            
            // 既然当前窗口已经满足条件，尝试去掉左边元素，看能否找到更短的窗口
            left++;
            
        } 
        else if (preSum[right] - preSum[left] < target) {
            // 当前窗口不满足条件，和太小了        
            // 右指针右移，将更多元素包含进窗口
            right++;
            
        }
    }
    return ans == Integer.MAX_VALUE ? 0 : ans;
}

LCR-006-两数之和II-输入有序数组

Fri, 30 Jan 2026 20:05:59 +0000

求解代码

    public int[] twoSum(int[] numbers, int target) {
        for(int i=0;i<numbers.length;i++){
            int left = i+1;
            int right = numbers.length-1;
            
            //二分查找是闭区间 [left, right]，等号保证最后一个元素被检查，避免漏查
            while (left<=right) {
                int mid = left+((right-left)>>1);
                if(target-numbers[i]==numbers[mid]){
                    return new int[]{i,mid};
                }else if(target-numbers[i]>numbers[mid]){
                    left=mid+1;
                }else{
                    right=mid-1;
                }
            }
        }
        return new int[]{-1,-1};
    }

小贴士

前文【哈希】两数之和是使用哈希做的，这次利用有序的特性，通过二分的方法完成。

LCR004-只出现一次的数字II

Thu, 29 Jan 2026 23:22:30 +0000

求解代码

    public int singleNumber(int[] nums) {
        int ans = 0;
        // 遍历int的每一个二进制位，i表示当前处理第i位（0是最低位，31是最高位）
        for (int i = 0; i < 32; ++i) {
            int total = 0; // 统计当前第i位的总1数

            for (int num : nums) {
                // 提取num的第i位值（0或1）并累加
                // (num >> i)：将num的第i位移到最低位
                // & 1：保留最低位，消去其他位，得到第i位的实际值（0/1）
                total += ((num >> i) & 1);
            }
            // 总1数%3≠0 → 唯一数的第i位是1
            if (total % 3 != 0) {
                // 将1写入ans的第i位：1<<i得到第i位为1、其余位为0的数，再和ans做或运算
                ans |= (1 << i);
            }
        }
        return ans;
    }

小贴士

对于二进制的每一位（0~31 位），数组中所有数的该位上的 1，只会来自两部分：出现 3 次的数的该位 1 ➕ 出现 1 次的数的该位 1。

由于 3 次的数的 1 相加后，总数一定是 3 的倍数，因此该位总 1 数 %3 的结果，就是唯一数在该位的取值（0 或 1）。

【模拟】顺时针旋转矩阵

Wed, 28 Jan 2026 21:03:56 +0000

求解代码

public int[][] rotateMatrix(int[][] mat, int n) {
        // 空矩阵、空方阵直接返回
        if (mat == null || n == 0) {
            return mat;
        }

        // 矩阵转置（行和列互换）
        for (int i = 0; i < n; i++) {
            for (int j = i; j < n; j++) {
                int tmp = mat[i][j];
                mat[i][j] = mat[j][i];
                mat[j][i] = tmp;
            }
        }

        // 反转转置后矩阵的每一行，完成顺时针90度旋转
        for (int[] row : mat) {
            reverse(row);
        }

        return mat;
    }

    // 双指针法原地反转一维数组
    private void reverse(int[] arr) {
        int left = 0;
        int right = arr.length - 1;
        while (left < right) {
            // 交换左右指针元素
            int tmp = arr[left];
            arr[left] = arr[right];
            arr[right] = tmp;
            left++;
            right--;
        }
    }

小贴士

j 从 0 开始会让对角线上下的元素对被交换两次，交换两次就等于没交换，而j从i开始能保证每个元素对只被交换一次。

【模拟】螺旋矩阵

Wed, 28 Jan 2026 20:33:10 +0000

求解代码

public ArrayList<Integer> spiralOrder(int[][] matrix) {
        ArrayList<Integer> ans = new ArrayList<>();
        // 处理空矩阵、空行、空列场景，避免空指针/数组越界
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return ans;
        }
        int m = matrix.length; // 矩阵行数
        int n = matrix[0].length; // 矩阵列数

        // 定义矩阵四个边界指针，初始指向边缘
        int left_bound = 0;
        int right_bound = n - 1;
        int up_bound = 0;
        int down_bound = m - 1;

        // 遍历所有元素后终止循环
        while (ans.size() < m * n) {
            // 方向1：从左到右遍历上边界行，遍历后上边界向下收缩
            if (up_bound <= down_bound) {
                for (int j = left_bound; j <= right_bound; j++) {
                    ans.add(matrix[up_bound][j]);
                }
                up_bound++;
            }

            // 方向2：从上到下遍历右边界列，遍历后右边界向左收缩
            if (left_bound <= right_bound) {
                for (int i = up_bound; i <= down_bound; i++) {
                    ans.add(matrix[i][right_bound]);
                }
                right_bound--;
            }

            // 方向3：从右到左遍历下边界行，遍历后下边界向上收缩
            if (up_bound <= down_bound) {
                for (int j = right_bound; j >= left_bound; j--) {
                    ans.add(matrix[down_bound][j]);
                }
                down_bound--;
            }

            // 方向4：从下到上遍历左边界列，遍历后左边界向右收缩
            if (left_bound <= right_bound) {
                for (int i = down_bound; i >= up_bound; i--) {
                    ans.add(matrix[i][left_bound]);
                }
                left_bound++;
            }
        }
        return ans;
    }

【三次翻转】旋转数组

Tue, 27 Jan 2026 23:25:59 +0000

求解代码

public int[] solve(int n, int m, int[] a) {
        m %= n;
        reverse(a, 0, n - 1);
        reverse(a, 0, m - 1);
        reverse(a, m, n - 1);
        return a;
    }

    private void reverse(int[] arr, int start, int end) {
        while (start < end) {
            swap(arr, start++, end--);
        }

    }

    private void swap(int[] arr, int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }

小贴士

因为右移 n 位 = 没动，右移 n + k 位 = 右移 k 位；

所以，要通过取余操作把 m 压缩到 [0, n-1] 范围。

【数组】分糖果问题

Tue, 27 Jan 2026 22:09:03 +0000

求解代码

public int candy(int[] arr) {
        if (arr == null || arr.length == 0) {
            return 0;
        }

        int n = arr.length;
        int[] candyCount = new int[n]; // 定义数组记录每个孩子最终应分得的糖果数
        int ans = 0; // 统计分发糖果的总数量

        // 每个孩子至少分得1颗糖果
        for(int i=0;i<arr.length;i++){
            candyCount[i]=1;
        }

        // 从左到右遍历数组，保证相邻孩子中，右侧评分更高的孩子糖果数多于左侧
        for(int i=1;i<n;i++){
            if(arr[i] > arr[i-1]){
                candyCount[i] = candyCount[i-1] + 1;
            }
        }

        // 从右到左遍历数组，保证相邻孩子中，左侧评分更高的孩子糖果数多于右侧
        for(int i=n-2;i>=0;i--){
            if(arr[i] > arr[i+1] && candyCount[i] <= candyCount[i+1]){
                candyCount[i] = candyCount[i+1] + 1;
            }
        }

        // 累加所有孩子的糖果数，得到分发的总数量
        for (int i = 0; i < n; i++) {
            ans += candyCount[i];
        }
        // 返回总糖果数
        return ans;
    }

【双指针】接雨水

Tue, 27 Jan 2026 21:13:29 +0000

求解代码

public long maxWater(int[] arr) {
        // 数组长度<3，无法形成凹坑接水，直接返回0
        if (arr == null || arr.length < 3) {
            return 0;
        }

        int left = 0; // 左指针
        int right = arr.length - 1; // 右指针
        long ans = 0; // 总积水量

        int leftMax = arr[left]; // 左指针左侧（含当前）的最大柱子高度，初始为左指针初始值
        int rightMax = arr[right]; // 右指针右侧（含当前）的最大柱子高度，初始为右指针初始值

        while (left < right) {
            // 更新左右最大高度→取最大值，记录遍历过的最高柱子
            leftMax = Math.max(leftMax, arr[left]);
            rightMax = Math.max(rightMax, arr[right]);

            // 当前位置的积水量由较小的最大高度决定，移动该侧指针可逐步统计积水量
            if (leftMax < rightMax) {
                ans += leftMax - arr[left];
                left++; 
            } else {
                ans += rightMax - arr[right];
                right--; 
            }
        }
        return ans; // 返回总积水量
    }

【双指针】盛水最多的容器

Tue, 27 Jan 2026 20:18:39 +0000

求解代码

public int maxArea(int[] height) {
        int left = 0; // 左指针
        int right = height.length - 1; // 右指针
        int ans = 0; // 记录最大面积，初始为0（面积非负）

        // 双指针相向遍历，直到指针相遇
        while (left < right) {
            // 计算当前容器面积并更新最大值：宽度(左右指针间距) × 有效高度(矮柱子决定，取最小值)
            ans = Math.max(ans, (right - left) * Math.min(height[right], height[left]));
            // 移动更矮的柱子指针（只有这样才有可能增大有效高度，获得更大面积）
            if (height[right] < height[left]) {
                right--; 
            } else {
                left++; 
            }
        }
        return ans; // 返回最大面积
    }

【滑动窗口】最长无重复子数组

Mon, 26 Jan 2026 23:57:22 +0000

求解代码

public int maxLength(int[] arr) {
        // 记录「当前滑动窗口内」每个元素的出现次数
        HashMap<Integer, Integer> window = new HashMap<>();

        int left = 0, right = 0; // 滑动窗口双指针，「左闭右开」区间
        int valid = 0; // 记录最长无重复子数组的长度

        while (right < arr.length) {
            int c = arr[right]; // 即将加入窗口的当前元素
            right++; // 右指针右移，扩大窗口

            // 更新窗口内元素计数
            window.put(c, window.getOrDefault(c, 0) + 1);

            // 当【当前元素】在窗口内重复（次数>1），收缩左指针，直到窗口内无重复
            while (window.get(c) > 1) {
                int d = arr[left]; // 即将移出窗口的左指针元素
                left++; // 左指针右移，收缩窗口
                window.put(d, window.get(d) - 1); // 移出元素的计数-1
            }

            // 更新最长无重复窗口的长度
            valid = Math.max(valid, right - left);
        }
        // 返回最终的最长长度
        return valid;
    }

【快手手撕】合并区间

Mon, 26 Jan 2026 21:05:27 +0000

求解代码

public ArrayList<Interval> merge(ArrayList<Interval> intervals) {

        ArrayList<Interval> ans = new ArrayList<>();

        // 边界处理：入参为null或空集合，直接返回空
        if (intervals == null || intervals.size() == 0) {
            return ans; 
        }

        // 按区间的start值升序排序
        Collections.sort(intervals, (a, b) -> (a.start - b.start));

        // 初始化【当前合并区间】为排序后的第一个区间
        Interval current = intervals.get(0);

        
        for (int i = 1; i < intervals.size(); i++) {
            // 取出当前遍历到的待对比区间
            Interval temp = intervals.get(i);
            // 重叠判断：待对比区间的start ≤ 当前合并区间的end → 两个区间重叠，需要合并
            if (temp.start <= current.end) {
                // 更新当前合并区间的end为两者end的最大值
                current.end = Math.max(current.end, temp.end);
            } else {
                // 将当前合并完成的区间加入结果集合
                ans.add(current);
                // 更新「当前合并区间」为当前遍历到的新区间，继续后续合并
                current = temp;
            }
        }

        // 手动将最后一个未加入的「当前合并区间」加入结果
        ans.add(current);

        // 返回最终合并结果
        return ans;
    }

小贴士

遍历中只有遇到非重叠区间时，才会把 上一个 current加入结果，而最后一个current没有后续区间对比，遍历结束后不会被自动加入，所以需要手动补充。

【双指针】合并两个有序数组

Mon, 26 Jan 2026 04:15:00 +0000

求解代码

public void merge(int A[], int m, int B[], int n) {
        int i = m - 1; // 指针i：指向A有效元素的最后一位
        int j = n - 1; // 指针j：指向B有效元素的最后一位
        int k = m + n - 1; // 指针k：指向A物理空间的最后一位（合并后元素的存放位置）

        // 同时遍历A、B的有效元素，取较大值放到A的k位置
        while (i >= 0 && j >= 0) {
            if (A[i] > B[j]) {
                A[k--] = A[i--];
            } else {
                A[k--] = B[j--];
            }
        }

        // 若A的有效元素先遍历完，将B剩余元素依次放入A的剩余位置
        if (i < 0) {
            while (j >= 0) {
                A[k--] = B[j--];
            }
        }
    }

三指针-三数之和

Sat, 17 Jan 2026 21:16:58 +0000

求解代码

 public ArrayList<ArrayList<Integer>> threeSum (int[] num) {
        ArrayList<ArrayList<Integer>> ans = new ArrayList<ArrayList<Integer>>();
        Arrays.sort(num);

        for(int i=0;i<num.length && num[i]<=0;i++){
            if(i>0&&num[i]==num[i-1]){
                continue;
            }
            int j=i+1,k=num.length-1;
            while (j<k) {
                int valuei=num[i];
                int valuej=num[j];
                int valuek=num[k];
                int sum = valuei+valuej+valuek;
                if(sum==0){
                    ans.add(new ArrayList<>(Arrays.asList(valuei,valuej,valuek)));
                }
                if(sum>0){
                    while (j<k&&num[k]==valuek) {
                        k--;
                    }
                }else{
                    while (j<k&&num[j]==valuej) {
                        j++;
                    }
                }
            }
        }
        return ans;
    }

小贴士

continue所在语句块的num[i]==num[i-1]主要是跳过重复的基准数，避免生成重复三元组。
num[j]==valuej和num[k]==valuek的作用也是一样的，本质上都是排序后数组的「重复元素相邻」，要跳过重复值。
第一个if语句只负责「添加结果」，和后续的逻辑无关，第二个独立的if-else负责「指针移动+去重」，覆盖所有情况。

比较版本号

Sat, 10 Jan 2026 22:26:28 +0000

求解代码

public int compare (String version1, String version2) {
        
		String[] str1 = version1.split("\\.");
		String[] str2 = version2.split("\\.");

		int len1 = str1.length;
		int len2 = str2.length;

		int len =len1>len2?len1:len2;

		for(int i=0;i<len;i++){
			int val1 = i<len1?Integer.parseInt(str1[i]):0;
			int val2 = i<len2?Integer.parseInt(str2[i]):0;
			if(val1>val2){
				return 1;
			}else if(val1<val2){
				return -1;
			}
		}
		return 0;

    }

二分法-旋转数组的最小数字

Sat, 10 Jan 2026 22:02:56 +0000

求解代码

对旋转数组来说，右子数组的数值整体更小，左子数组的数值整体更大。

数组的最小值一定是右子数组的第一个元素。

public int minNumberInRotateArray (int[] nums) {
        if(nums.length==0){
			return 0;
		}

		int i=0;
		int j=nums.length-1;

		while(i<j){
			int mid = i+((j-i)>>1);
			if(nums[mid]>nums[j]){
				i=mid+1;
			}else if(nums[mid]<nums[j]){
				j=mid;
			}else{
				j--;
			}
		}

		return nums[i];
    }

归并-数组中的逆序对

Sat, 10 Jan 2026 21:38:31 +0000

求解代码

    int mod = 1000000007;

    long mergeSort(int[] nums, int left, int right) {
        if (left >= right) {
            return 0;
        }

        int mid = left + ((right - left) >> 1);
        // 分治计算左右区间，并立即取模
        long res = (mergeSort(nums, left, mid) + mergeSort(nums, mid + 1, right)) % mod;
        
        int[] temp = new int[right - left + 1];
        int i = left;
        int j = mid + 1;
        int k = 0;

        while (i <= mid && j <= right) {
            // 严格判断nums[i] <= nums[j]，仅大于时统计逆序对
            if (nums[i] <= nums[j]) {
                temp[k++] = nums[i++];
            } else {
                temp[k++] = nums[j++];
                // 累加后立即取模，防止溢出
                res = (res + mid - i + 1) % mod;
            }
        }
        // 拷贝左区间剩余元素
        while (i <= mid) {
            temp[k++] = nums[i++];
        }
        // 拷贝右区间剩余元素
        while (j <= right) {
            temp[k++] = nums[j++];
        }
        // 覆盖回原数组
        for (k = 0, i = left; k < temp.length; k++, i++) {
            nums[i] = temp[k];
        }
        return res;
    }

    public int InversePairs(int[] nums) {
        if (nums == null || nums.length <= 1) {
            return 0;
        }
        return (int) (mergeSort(nums, 0, nums.length - 1) % mod);
    }

二分法-二维数组中的查找

Sat, 10 Jan 2026 17:29:11 +0000

求解代码

这道题因为每一行从左到右都是递增的，且每一列从上到下也都是递增的。

我们不难发现，左上角是最小值，右下角是最大值。

左下的元素大于它上方的元素，小于它右方的元素。

所以，我们可以以左下角为起点，如果它小于target，则往右移找更大的；

如果它大于target，则往上移找更小的。

public boolean Find (int target, int[][] array) {

		if(array.length==0||array[0].length==0){
			return false;
		}

		int n = array.length;
		int m = array[0].length;

		for(int i=n-1,j=0;i>=0&&j<m;){
			if(array[i][j]<target){
				j++;
			}else if(array[i][j]==target){
				return true;
			}else{
				i--;
			}
		}
		return false;
    }

二分查找-I

Fri, 09 Jan 2026 22:09:01 +0000

求解代码

public int search (int[] nums, int target) {
        // 左指针：起始下标
        int left = 0;
        // 右指针：结束下标，闭区间 [left, right]
        int right = nums.length - 1;

        while (left <= right) {

            int mid = left + ((right - left) >> 1);
            if (nums[mid] < target) {
                // 目标值在右半区，左指针右移
                left = mid + 1;
            } else if (nums[mid] == target) {
                // 找到目标值，返回对应下标
                return mid;
            } else {
                // 目标值在左半区，右指针左移
                right = mid - 1;
            }
        }
        // 遍历完无目标值，返回-1
        return -1;
    }

Leetcode2092找出知晓秘密的所有专家

Sun, 04 Jan 2026 19:53:26 +0000

求解代码

public static int MAXN = 100001;
	public static int[] father = new int[MAXN];
	public static boolean[] secret = new boolean[MAXN];

	public static void build(int n,int first){
		for(int i=0;i<n;i++){
			father[i]=i;
			secret[i]=false;
		}
		father[first]=0;
		secret[0]=true;
	}

	public static int find(int i){
		if(i!=father[i]){
			father[i]=find(father[i]);
		}
		return father[i];
	}

	public static void union(int x,int y){
		int fx = find(x);
		int fy = find(y);

		if(fx!=fy){
			father[fx]=fy;
			secret[fy]|=secret[fx];
		}
	}

	public static List<Integer> findAllPeople(int n,int[][] meetings,int first){
		build(n, first);

		Arrays.sort(meetings,(a,b)->a[2]-b[2]);
		int m = meetings.length;
		for(int l=0,r;l<m;){
			r=l;
			while (r+1<m&&meetings[l][2]==meetings[r+1][2]) {
				r++;
			}

			for(int i=l;i<=r;i++){
				union(meetings[i][0], meetings[i][1]);
			}

			for(int i=l,a,b;i<=r;i++){
				a=meetings[i][0];
				b=meetings[i][1];
				if(!secret[find(a)]){
					father[a]=a;
				}
				if(!secret[find(b)]){
					father[b]=b;
				}
			}
			l=r+1;
		}

		List<Integer> ans = new ArrayList<>();
		for(int i=0;i<n;i++){
			if(secret[find(i)]){
				ans.add(i);
			}
		}
		return ans;
	}

Leetcode839相似字符串组

Sat, 03 Jan 2026 21:34:46 +0000

题目分析

从0~n-1遍历单词，每个单词与后续单词进行比较，如果不在同一集合且相似则合并。

遍历两个字符串，记录不同位置的数量，如果不同位置的数量在2个以内则相似，超过了2个则不相似。

求解代码

public static int MAXN = 301;
	public static int[] father = new int[MAXN];
	public static int sets;
	public static void build(int n){
		for(int i=0;i<n;i++){
			father[i]=i;
		}
		sets = n;
	}

	public static int find(int i){
		if(i!=father[i]){
			father[i]=find(father[i]);
		}
		return father[i];
	}

	public static void union(int x,int y){
		int fx = find(x);
		int fy = find(y);
		if(fx!=fy){
			father[fx]=fy;
			sets--;
		}
	}

	public static int numSimilarGroups(String[] strs){
		int n = strs.length;
		int m = strs[0].length();
		build(n);

		for(int i=0;i<n;i++){
			for(int j=i+1;j<n;j++){
				if(find(i)!=find(j)){
					int diff = 0;
					for(int k=0;k<m&&diff<3;k++){
						if(strs[i].charAt(k)!=strs[j].charAt(k)){
							diff++;
						}
					}
					if(diff==0||diff==2){
						union(i, j);
					}
				}
			}
		}
		return sets;
	}

Leetcode765情侣牵手

Sat, 03 Jan 2026 20:56:51 +0000

代码求解

初始化并查集，每对情侣初始集合只有自身，遍历数组，计算相邻两人情侣编号并合并，合并之后集合数量减一，最后用总情侣对数减去集合数量得到结果。

public static int minSwapsCouples(int[] row){
		int n = row.length;
		build(n/2);
		for(int i=0;i<n;i+=2){
			union(row[i]/2,row[i+1]/2);
		}
		return n/2-sets;
	}

	public static int MAXN = 31;
	public static int[] father = new int[MAXN];
	public static int sets;

	public static void build(int m){
		for(int i=0;i<m;i++){
			father[i]=i;
		}
		sets = m;
	}

	public static int find(int i){
		if(i!=father[i]){
			father[i]=find(father[i]);
		}
		return father[i];
	}

	public static void union(int x,int y){
		int fx = find(x);
		int fy = find(y);
		if(fx!=fy){
			father[fx]=fy;
			sets--;
		}
	}

Leetcode1438绝对值不超过限制的最长连续子数组

Thu, 01 Jan 2026 20:50:33 +0000

题目分析

如果一个子数组达标，也就是它内部的最大值减去最小值小于等于给定限制limit，则其内部任意小范围一定也达标，因为范围变小，最大值只可能变小或者不变，而最小值只可能变大或者不变。

如果一个子数组不达标，则再扩大范围一定会更加不达标，因为范围变大，最大值只可能上升或者不变，而最小值只可能下降或者不变。

先固定左边界l，右边界r不断右移扩展窗口，每次判断新加入的数是否使窗口达标，如果达标，则继续拓展，不达标则停止，计算以当前l开头的达标子数组的最大长度。

求解代码

	public static int MAXN = 100001;

	public static int[] maxDeque = new int[MAXN];
	public static int[] minDeque = new int[MAXN];

	public static int maxh,maxt,minh,mint;
	public static int[] arr;
	public static int longestSubarray(int[] nums,int limit){
		maxh = maxt = minh = mint = 0;
		arr = nums;
		int n = arr.length;
		int ans = 0;
		for(int l=0,r=0;l<n;l++){
			while(r<n&&ok(limit,nums[r])){
				push(r++);
			}
			ans = Math.max(ans, r-l);
			pop(l);
		}
		return ans;
	}

	public static boolean ok(int limit,int number){
		int max = maxh <maxt?Math.max(arr[maxDeque[maxh]], number):number;
		int min = minh <mint?Math.min(arr[minDeque[minh]], number):number;
		return max-min<=limit;
	}

	public static void push(int r){
		while (maxh<maxt&&arr[maxDeque[maxt-1]]<=arr[r]) {
			maxt--;
		}
		maxDeque[maxt++]=r;
		while (minh<mint&&arr[minDeque[mint-1]]>=arr[r]) {
			mint--;
		}
		minDeque[mint++]=r;
	}

	public static void pop(int l) {
		if (maxh < maxt && maxDeque[maxh] == l) {
			maxh++;
		}
		if (minh < mint && minDeque[minh] == l) {
			minh++;
		}
	}

怎么实现一个滑动验证码功能-又如何防止被机器识别破解

Tue, 30 Dec 2025 15:35:50 +0000

滑动验证码应该大家都不陌生，在登录的时候都基本上遇到过，那怎么实现这样一个功能呢？

核心其实就两个，一个是后端造图，另一个是行为校验。

在后端随机选择一张背景图，再随机选择一个位置(X,Y)，利用OpenCV或者Java的BufferedImage算法扣出一块拼图。

然后，在后端把背景图和拼图块转成Base64给前端，同时把正确的X坐标存到Redis中。

前端主要监听鼠标或者触摸事件，当用户拖动滑块时，前端不仅要记录最终滑动的距离，还要记录整个滑动轨迹。

当鼠标松开时，再把数据发给后端。

为了防止被机器识别破解，需要在后端进行双重校验。

第一重是判断前端传来的X偏移量和Redis中存储的X是否匹配；

第二重则是对轨迹进行分析，如果轨迹太过完美，可以直接判定为机器人。

因为一般来说，机器人的轨迹是匀速的，直线的或者是一条完美的数学曲线。

但是，人的轨迹就很难做到这么完美，可能会有抖动，先快后慢或者还可能有回退。

同时运行N台电脑的最长时间

Sun, 28 Dec 2025 19:56:01 +0000

求解代码

maxRunTime方法

假设所有电池的最大电量是max，如果此时sum>(long)max*num，那么最终的供电时间一定会大于等于max，由此也能推出最终的答案为sum/num。

对于sum<=(long)max*num的情况，在0~max区间内不断二分查找即可。

	public static long maxRunTime(int num,int[] arr){
		int max = 0;
		long sum = 0;
		for(int x:arr){
			max = Math.max(max,x);
			sum+=x;
		}

		if(sum>(long)max*num){
			return sum/num;
		}

		int ans = 0;
		for(int l=0,r=max,m;l<=r;){
			m= l+((r-l)>>1);
			if(f(arr,num,m)){
				ans = m;
				l = m+1;
			}else{
				r=m-1;
			}
		}
		return ans;
	}

f方法

	public static boolean f(int[] arr, int num, int time) {
		long sum = 0;
		for (int x : arr) {
			if (x > time) {
				num--;
			} else {
				sum += x;
			}
			if (sum >= (long) num * time) {
				return true;
			}
		}
		return false;
	}

二分法找出第k小的数对距离

Sat, 27 Dec 2025 20:10:12 +0000

代码求解

smallestDistancePair方法

先排序，用最大值减去最小值求出最大的数对距离。

通过二分法调用f函数找出区间内满足要求的数对，然后不停地二分。

	public static int smallestDistancePair(int[] nums,int k){
		int n = nums.length;
		Arrays.sort(nums);
		int ans = 0;
		for(int l=0,r=nums[n-1]-nums[0],m,cnt;l<=r;){
			m = l+((r-l)>>1);
			cnt = f(nums,m);
			if(cnt>=k){
				ans = m;
				r = m-1;
			}else{
				l=m+1;
			}
		}
		return ans;
	}

f方法

求arr中数对距离小于limit的数对总共有几对。

	public static int f(int[] arr,int limit){
		int ans = 0;
		for(int l=0,r=0;l<arr.length;l++){
			while(r+1<arr.length && arr[r+1]-arr[l]<=limit){
				r++;
			}
			ans+=r-l;
		}
		return ans;
	}

机器人跳跃问题

Sat, 27 Dec 2025 19:21:54 +0000

求解代码

Main方法

	public static int MAXN = 100001;

	public static int[] arr = new int[MAXN];

	public static int n;

	public static void main(String[] args)throws IOException{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StreamTokenizer in = new StreamTokenizer(br);
		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
		while(in.nextToken()!=StreamTokenizer.TT_EOF){
			n = (int)in.nval;
			int l = 0;
			int r = 0;
			for(int i=1;i<=n;i++){
				in.nextToken();
				arr[i]=(int)in.nval;
				r=Math.max(r,arr[i]);
			}
			out.println(compute(l,r,r));
		}
		out.flush();
		out.close();
		br.close();
	}

compute方法

区间[l,r]表示通关所需要的最小的能量范围， max表示所有建筑的最大高度。

	public static int compute(int l,int r,int max){
		int m,ans = -1;
		while(l<=r){
			m = l+((r-l)>>1);
			if(f(m,max)){
				ans = m;
				r=m-1;
			}else{
				l=m+1;
			}
		}
		return ans;
	}

f方法

初始能量设置为energy，max是建筑的最大高度，这里有个需要注意的点就是：

初始能量越小，它就越吃亏，遇到比它高的建筑，它减小的更快；遇到比它低的建筑，增加的也更慢。

一旦能量超过了建筑高度的最大值，肯定可以通关，可以直接返回。

public static boolean f(int energy,int max){
		for(int i=1;i<=n;i++){
			if(energy<=arr[i]){
				energy-=arr[i]-energy;
			}else{
				energy+=energy-arr[i];
			}

			if(energy>=max){
				return true;
			}

			if(energy<0){
				return false;
			}
		}
		return true;
	}

下雨了-算法帮你算能接多少水-☔

Mon, 15 Dec 2025 20:48:29 +0000

求解思路

这道题的关键在于理解每个位置能接多少水。

想象你站在某个位置i上，这个位置能接住的水量取决于什么呢?

其实就是左右两边的"围墙"能托住多高的水。

具体来说就是左右两边最高的柱子,其中，这两个高度中较矮的那个决定了水位线,然后用这个水位线减去当前位置的高度,就是这个位置能接的水量。

如果当前位置本身就比水位线高,那自然接不住水。

所以问题就转化成了:

对于每个位置,我们需要知道它左边的最大值和右边的最大值,然后取两者的较小值作为水位,最后累加每个位置能接的水量即可。

方法1

既然需要知道每个位置左右两边的最大值,最直接的想法就是提前算好。

public static int trap(int[] nums) {
    int n = nums.length;
    int[] lmax = new int[n];
    int[] rmax = new int[n];
    
    // 计算每个位置左边的最大值
    lmax[0] = nums[0];
    for (int i = 1; i < n; i++) {
        lmax[i] = Math.max(lmax[i - 1], nums[i]);
    }
    
    // 计算每个位置右边的最大值
    rmax[n - 1] = nums[n - 1];
    for (int i = n - 2; i >= 0; i--) {
        rmax[i] = Math.max(rmax[i + 1], nums[i]);
    }
    
    // 累加每个位置能接的水量
    int ans = 0;
    for (int i = 1; i < n - 1; i++) {
        ans += Math.max(0, Math.min(lmax[i - 1], rmax[i + 1]) - nums[i]);
    }
    return ans;
}

方法2

假设左边最大值小于等于右边最大值,那么左指针位置的接水量只取决于左边最大值,右边再高也没用。反之亦然。

public static int trap(int[] nums) {
    int l = 1, r = nums.length - 2;
    int lmax = nums[0], rmax = nums[nums.length - 1];
    int ans = 0;
    
    while (l <= r) {
        if (lmax <= rmax) {
            // 左边矮,左指针位置的水量确定
            ans += Math.max(0, lmax - nums[l]);
            lmax = Math.max(lmax, nums[l++]);
        } else {
            // 右边矮,右指针位置的水量确定
            ans += Math.max(0, rmax - nums[r]);
            rmax = Math.max(rmax, nums[r--]);
        }
    }
    return ans;
}

如果觉得有帮助，欢迎点赞、关注、转发~

面试常考-如何原地重排数组-这个思路绝了

Sat, 13 Dec 2025 18:49:08 +0000

解题思路

这道题我们用两个指针分别追踪奇数位和偶数位,每次检查最后一个元素是奇数还是偶数,然后把它交换到对应的位置上。

比如最后一个元素是奇数,就把它换到下一个需要填充的奇数位(1, 3, 5…),换过来的元素又成为新的"最后一个元素",继续这个过程。

这样做的优势是不需要额外空间,而且每次交换都在推进进度,最终当奇数位和偶数位都填满后,数组自然就符合要求了。

举个栗子

输入: [4, 2, 5, 7]

执行过程:

初始: [4, 2, 5, 7],最后元素 7(奇数) → 交换到 odd=1 → [4, 7, 5, 2]
最后元素 2(偶数) → 交换到 even=0 → [2, 7, 5, 4]
最后元素 4(偶数) → 交换到 even=2 → [2, 7, 4, 5]
最后元素 5(奇数) → 交换到 odd=3 → [2, 7, 4, 5]

输出: [2, 7, 4, 5]

代码实现

public static int[] sortArrayByParityII(int[] nums) {
    int n = nums.length;
    for (int odd = 1, even = 0; odd < n && even < n;) {
        if ((nums[n - 1] & 1) == 1) {
            // 最后一个元素是奇数,放到奇数位
            swap(nums, odd, n - 1);
            odd += 2;
        } else {
            // 最后一个元素是偶数,放到偶数位
            swap(nums, even, n - 1);
            even += 2;
        }
    }
    return nums;
}

public static void swap(int[] nums, int i, int j) {
    int tmp = nums[i];
    nums[i] = nums[j];
    nums[j] = tmp;
}

如果觉得有帮助，欢迎点赞、关注、转发~

如何用最短替换让字符串变平衡

Wed, 10 Dec 2025 20:45:48 +0000

求解思路

这道题与其考虑"替换哪些字符",不如想"保留哪些字符"。

我们要找的是一个最短的连续子串,这个子串里包含了所有"多余"的字符,只要把这个子串替换掉,剩下的字符串自然就平衡了。

首先统计每种字符的出现次数,如果某个字符出现次数超过了 n/4,那它就是"多余"的,多出来的部分就是"债务";

然后用滑动窗口去找一个最短的子串,这个子串恰好包含了所有这些多余的字符,当窗口内包含的多余字符数量刚好抵消了所有债务时,这个窗口的长度就是答案的候选值,在所有候选值中取最小即可。

代码实现

public static int balancedString(String str) {
    int n = str.length();
    int[] s = new int[n];
    int[] cnts = new int[4];
    
    // 字符映射并统计频次: Q->0, W->1, E->2, R->3
    for (int i = 0; i < n; i++) {
        char c = str.charAt(i);
        s[i] = c == 'W' ? 1 : (c == 'E' ? 2 : (c == 'R' ? 3 : 0));
        cnts[s[i]]++;
    }
    
    // 计算每种字符的"债务"(多余量)
    int debt = 0;
    for (int i = 0; i < 4; i++) {
        if (cnts[i] < n / 4) {
            cnts[i] = 0;  // 不足的字符无需处理
        } else {
            cnts[i] = n / 4 - cnts[i];  // 转为负数表示多余量
            debt -= cnts[i];  // 累计总债务
        }
    }
    
    // 如果已经平衡,直接返回
    if (debt == 0) {
        return 0;
    }
    
    // 滑动窗口找最短替换子串
    int ans = Integer.MAX_VALUE;
    for (int l = 0, r = 0; r < n; r++) {
        // 右边界扩展,收集多余字符
        if (cnts[s[r]]++ < 0) {
            debt--;
        }
        
        // 债务清零时,尝试收缩左边界
        if (debt == 0) {
            while (cnts[s[l]] > 0) {
                cnts[s[l++]]--;
            }
            ans = Math.min(ans, r - l + 1);
        }
    }
    
    return ans;
}

如果觉得有帮助，欢迎点赞、关注、转发~

加油站环路问题

Tue, 09 Dec 2025 21:41:21 +0000

求解思路

这道题我们把环形数组想象成展开的线性数组（通过取模实现），然后用一个窗口[l, r)来表示从l站出发能走到的范围，窗口内维护一个油量累加和sum。

每次尝试让窗口右边界r向右扩展，如果加上r站的净油量（gas[r] - cost[r]）后sum还是非负的，说明能走到r站，就继续扩展；

一旦发现扩展到某站会让sum变负，说明从l出发走不通，此时直接跳过整个窗口，让新起点从r+1开始尝试。

这样做的合理性在于，如果从l出发走不到r，那么从l到r之间的任何一站出发也走不到r（因为中间任何一站的初始油量都不如从l站累积过来的多），所以可以直接跳过这些站点，大大减少了尝试次数。当某个起点l的窗口成功扩展到覆盖n个站点时，就找到了答案。

代码实现

public static int canCompleteCircuit(int[] gas, int[] cost) {
    int n = gas.length;
    // 窗口范围[l, r)，左闭右开
    for (int l = 0, r = 0, sum; l < n; l = r + 1, r = l) {
        sum = 0;
        // 尝试扩展窗口右边界
        while (sum + gas[r % n] - cost[r % n] >= 0) {
            // 检查是否已经转了一圈
            if (r - l + 1 == n) {
                return l;
            }
            // r位置进入窗口，累加净油量
            sum += gas[r % n] - cost[r % n];
            r++;
        }
    }
    return -1;
}

如果觉得有帮助，欢迎点赞、关注、转发~

力场重叠问题

Fri, 05 Dec 2025 23:17:20 +0000

求解思路

这道题的本质是求平面上被最多矩形覆盖的点的覆盖次数。

直观的想法是遍历平面上每个点统计覆盖次数，但坐标范围可能很大，暴力枚举会超时。

我们可以观察到虽然坐标值可能很大，但真正有意义的分界线只有每个矩形的四条边，最多2n条竖线和2n条横线，它们将平面切分成最多O(n²)个小矩形区域，每个区域内的覆盖次数是相同的。

我们可以用坐标压缩把这些关键坐标映射到较小的编号上，将问题规模从无限大的平面压缩到有限的网格。

接下来的问题是如何快速标记每个矩形覆盖了哪些网格，如果逐个网格标记会是O(n³)复杂度。

对于一个矩形区域(a,b)到(c,d)，我们只需要在左上角(a,b)加1，右下角外侧(c+1,d+1)加1，右上角外侧(c+1,b)减1，左下角外侧(a,d+1)减1，这样做完所有矩形的标记后，从左上到右下做二维前缀和还原，每个格子的值就是它被多少个矩形覆盖的次数。

代码实现

public static int fieldOfGreatestBlessing(int[][] fields) {
    int n = fields.length;
    // 收集所有矩形的边界坐标
    long[] xs = new long[n << 1];
    long[] ys = new long[n << 1];
    for (int i = 0, k = 0, p = 0; i < n; i++) {
        long x = fields[i][0];
        long y = fields[i][1];
        long r = fields[i][2];
        // 坐标乘2避免小数，左边界和右边界
        xs[k++] = (x << 1) - r;
        xs[k++] = (x << 1) + r;
        ys[p++] = (y << 1) - r;
        ys[p++] = (y << 1) + r;
    }
    
    // 坐标压缩：排序去重
    int sizex = sort(xs);
    int sizey = sort(ys);
    
    // 二维差分数组
    int[][] diff = new int[sizex + 2][sizey + 2];
    
    // 对每个矩形在差分数组上标记
    for (int i = 0; i < n; i++) {
        long x = fields[i][0];
        long y = fields[i][1];
        long r = fields[i][2];
        // 找到压缩后的坐标编号
        int a = rank(xs, (x << 1) - r, sizex);
        int b = rank(ys, (y << 1) - r, sizey);
        int c = rank(xs, (x << 1) + r, sizex);
        int d = rank(ys, (y << 1) + r, sizey);
        // 二维差分标记
        add(diff, a, b, c, d);
    }
    
    // 还原真实覆盖次数并求最大值
    int ans = 0;
    for (int i = 1; i < diff.length; i++) {
        for (int j = 1; j < diff[0].length; j++) {
            diff[i][j] += diff[i - 1][j] + diff[i][j - 1] - diff[i - 1][j - 1];
            ans = Math.max(ans, diff[i][j]);
        }
    }
    return ans;
}

// 排序去重，返回有效长度
public static int sort(long[] nums) {
    Arrays.sort(nums);
    int size = 1;
    for (int i = 1; i < nums.length; i++) {
        if (nums[i] != nums[size - 1]) {
            nums[size++] = nums[i];
        }
    }
    return size;
}

// 二分查找坐标对应的压缩编号
public static int rank(long[] nums, long v, int size) {
    int l = 0, r = size - 1;
    int ans = 0;
    while (l <= r) {
        int m = (l + r) / 2;
        if (nums[m] >= v) {
            ans = m;
            r = m - 1;
        } else {
            l = m + 1;
        }
    }
    return ans + 1;  // 编号从1开始
}

// 二维差分标记矩形区域
public static void add(int[][] diff, int a, int b, int c, int d) {
    diff[a][b] += 1;
    diff[c + 1][d + 1] += 1;
    diff[c + 1][b] -= 1;
    diff[a][d + 1] -= 1;
}

如果觉得有帮助，欢迎点赞、关注、转发~

邮票覆盖问题

Thu, 04 Dec 2025 23:33:06 +0000

求解思路

这道题我们先构建原始网格的前缀和数组，这样就能在O(1)时间内判断任意矩形区域是否全为0（即没有障碍物）。

接着遍历所有可能的邮票位置，对于每个能贴的位置，不直接在原矩阵上标记，而是在差分矩阵中记录这次覆盖操作，差分矩阵的巧妙之处在于只需修改四个角点就能表示整个矩形的覆盖。

当所有邮票都贴完后，对差分矩阵做一次前缀和还原，就能得到每个格子被覆盖的次数。

最后检查原始网格中所有的空洞位置，如果某个空洞在还原后的差分矩阵中值为0，说明它没有被任何邮票覆盖，返回false，否则返回true。

完整代码实现

public static boolean possibleToStamp(int[][] grid, int h, int w) {
    int n = grid.length;
    int m = grid[0].length;
    
    // 构建前缀和数组，用于快速查询矩形区域的和
    // sum[i][j]表示从(0,0)到(i-1,j-1)的矩形区域累加和
    int[][] sum = new int[n + 1][m + 1];
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            sum[i + 1][j + 1] = grid[i][j];
        }
    }
    // 将sum转换为真正的前缀和数组
    build(sum);
    
    // 创建差分矩阵，用于高效记录邮票覆盖情况
    // 多开一圈是为了处理边界情况，避免数组越界
    int[][] diff = new int[n + 2][m + 2];
    
    // 遍历所有可能的邮票左上角位置(a,b)
    for (int a = 1, c = a + h - 1; c <= n; a++, c++) {
        for (int b = 1, d = b + w - 1; d <= m; b++, d++) {
            // (a,b)是左上角坐标(1-indexed)
            // (c,d)是右下角坐标，由邮票规格h×w计算得出
            // 如果这个区域的和为0，说明区域内全是空洞，可以贴邮票
            if (sumRegion(sum, a, b, c, d) == 0) {
                // 在差分矩阵中标记这次邮票覆盖操作
                add(diff, a, b, c, d);
            }
        }
    }
    
    // 对差分矩阵做前缀和还原，得到每个位置被覆盖的次数
    build(diff);
    
    // 检查原始网格中的所有空洞是否都被覆盖
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            // grid[i][j] == 0表示这是一个空洞
            // diff[i + 1][j + 1] == 0表示这个空洞没有被任何邮票覆盖
            if (grid[i][j] == 0 && diff[i + 1][j + 1] == 0) {
                return false;
            }
        }
    }
    return true;
}

// 将矩阵原地转换为前缀和数组
// 转换后m[i][j]表示从(0,0)到(i,j)的矩形区域累加和
public static void build(int[][] m) {
    for (int i = 1; i < m.length; i++) {
        for (int j = 1; j < m[0].length; j++) {
            // 前缀和公式：当前值 = 原值 + 上方和 + 左方和 - 左上角和(减去重复计算部分)
            m[i][j] += m[i - 1][j] + m[i][j - 1] - m[i - 1][j - 1];
        }
    }
}

// 利用前缀和数组快速计算矩形区域(a,b)到(c,d)的累加和
public static int sumRegion(int[][] sum, int a, int b, int c, int d) {
    // 容斥原理：大矩形 - 上方矩形 - 左方矩形 + 左上角矩形(加回多减的部分)
    return sum[c][d] - sum[c][b - 1] - sum[a - 1][d] + sum[a - 1][b - 1];
}

// 差分数组操作：给矩形区域(a,b)到(c,d)整体加1
// 差分矩阵的核心：只修改四个角点，后续通过前缀和还原出整个矩形的覆盖情况
public static void add(int[][] diff, int a, int b, int c, int d) {
    diff[a][b] += 1;           // 左上角+1
    diff[c + 1][d + 1] += 1;   // 右下角外侧+1
    diff[c + 1][b] -= 1;       // 左下角外侧-1
    diff[a][d + 1] -= 1;       // 右上角外侧-1
}

如果觉得有帮助，欢迎点赞、关注、转发~

矩阵区间更新TLE-试试二维差分

Wed, 03 Dec 2025 21:52:12 +0000

这道题如果用暴力方法，每次更新都要遍历子矩阵内的所有元素，时间复杂度是 O(q×n×m)，数据量大时会超时。

求解思路

在一维数组中，只需要在区间起点加k、终点后一位减k，最后做前缀和就能还原出整个数组。

二维情况下原理相同，只是标记变成了四个角点的操作。

具体来说，要给矩形区域 (a,b) 到 (c,d) 加上 k，在左上角 (a,b) 加k表示从这里开始增加，在右下角外侧的 (c+1,b) 和 (a,d+1) 各减k表示横向和纵向的增加到此为止,最后在 (c+1,d+1) 再加k来抵消多减的部分。

完成所有标记后,通过二维前缀和还原就能得到每个位置的真实值,整个过程每次更新只需要O(1)时间,总体复杂度可以降到O(q + n×m)。

代码实现

import java.io.*;

public class Main {
    public static int MAXN = 1005;
    public static int MAXM = 1005;
    public static long[][] diff = new long[MAXN][MAXM];
    public static int n, m, q;
    
    // 区间更新：给矩形区域(a,b)到(c,d)加上k
    public static void add(int a, int b, int c, int d, int k) {
        diff[a][b] += k;           // 左上角加k
        diff[c + 1][b] -= k;       // 左下角外减k
        diff[a][d + 1] -= k;       // 右上角外减k
        diff[c + 1][d + 1] += k;   // 右下角外加k
    }
    
    // 通过二维前缀和还原矩阵
    public static void build() {
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                diff[i][j] += diff[i-1][j] + diff[i][j-1] - diff[i-1][j-1];
            }
        }
    }
    
    // 清空差分数组
    public static void clear() {
        for (int i = 1; i <= n + 1; i++) {
            for (int j = 1; j <= m + 1; j++) {
                diff[i][j] = 0;
            }
        }
    }
    
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StreamTokenizer in = new StreamTokenizer(br);
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
        
        while (in.nextToken() != StreamTokenizer.TT_EOF) {
            n = (int) in.nval;
            in.nextToken();
            m = (int) in.nval;
            in.nextToken();
            q = (int) in.nval;
            
            // 读入原始矩阵并标记
            for (int i = 1; i <= n; i++) {
                for (int j = 1; j <= m; j++) {
                    in.nextToken();
                    add(i, j, i, j, (int) in.nval);
                }
            }
            
            // 处理q次区间更新操作
            for (int i = 1, a, b, c, d, k; i <= q; i++) {
                in.nextToken();
                a = (int) in.nval;
                in.nextToken();
                b = (int) in.nval;
                in.nextToken();
                c = (int) in.nval;
                in.nextToken();
                d = (int) in.nval;
                in.nextToken();
                k = (int) in.nval;
                add(a, b, c, d, k);
            }
            
            // 还原矩阵
            build();
            
            // 输出结果
            for (int i = 1; i <= n; i++) {
                out.print(diff[i][1]);
                for (int j = 2; j <= m; j++) {
                    out.print(" " + diff[i][j]);
                }
                out.println();
            }
            
            clear();
        }
        
        out.flush();
        out.close();
        br.close();
    }
}

如果觉得有帮助，欢迎点赞、关注、转发~

二维前缀和妙用-快速检测边框正方形

Tue, 02 Dec 2025 23:15:04 +0000

求解思路

这道题的核心是枚举所有可能的正方形，然后快速判断其边框是否全为1。

我们首先把原始矩阵转换成二维前缀和数组，这样就能在O(1)时间内计算任意矩形区域内1的个数。

接下来枚举每个可能的左上角点，从已知的最大边长开始向外扩展，对于每个候选正方形，我们计算整个正方形区域的1的个数，再减去内部正方形的1的个数，如果结果等于4条边上应有的格子数（即4×(边长-1)），就说明边框全是1，此时更新答案。

这种方法的巧妙之处在于利用前缀和避免了逐个检查边框元素，同时通过从已知答案开始扩展，减少了不必要的计算。

代码实现

public static int largest1BorderedSquare(int[][] g) {
    int n = g.length;
    int m = g[0].length;
    build(n, m, g);
    
    // 特判：矩阵全是0
    if (sum(g, 0, 0, n - 1, m - 1) == 0) {
        return 0;
    }
    
    int ans = 1;
    for (int a = 0; a < n; a++) {
        for (int b = 0; b < m; b++) {
            // 枚举左上角(a,b)，从当前最大边长+1开始尝试
            for (int c = a + ans, d = b + ans, k = ans + 1; 
                 c < n && d < m; c++, d++, k++) {
                // 边框1的个数 = 整个正方形的1 - 内部正方形的1
                if (sum(g, a, b, c, d) - sum(g, a + 1, b + 1, c - 1, d - 1) 
                    == (k - 1) << 2) {
                    ans = k;
                }
            }
        }
    }
    return ans * ans;
}

// 构建二维前缀和数组
public static void build(int n, int m, int[][] g) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            g[i][j] += get(g, i, j - 1) + get(g, i - 1, j) 
                     - get(g, i - 1, j - 1);
        }
    }
}

// 查询矩形区域和
public static int sum(int[][] g, int a, int b, int c, int d) {
    return a > c ? 0 : (g[c][d] - get(g, c, b - 1) 
                       - get(g, a - 1, d) + get(g, a - 1, b - 1));
}

// 安全获取值
public static int get(int[][] g, int i, int j) {
    return (i < 0 || j < 0) ? 0 : g[i][j];
}

如果觉得有帮助，欢迎点赞、关注、转发~

二维区域和检索-一文搞懂前缀和优化技巧

Mon, 01 Dec 2025 23:03:32 +0000

求解思路

这道题可以这样理解：

就像一维数组可以通过前缀和快速计算区间和一样,二维矩阵也可以预处理出每个位置到左上角(0,0)的矩形区域和,这样查询任意矩形区域时只需要用类似容斥原理的方式,通过四个角的前缀和做加减运算就能O(1)得到结果。

具体来说：

我们创建一个比原矩阵大一圈的前缀和数组sum,其中sum[i][j]表示从(0,0)到(i-1,j-1)的矩形区域和,

构建时利用已经计算好的左边和上边的前缀和,加上当前元素,再减去重复计算的左上角区域即可;

查询时,目标区域的和等于右下角的前缀和减去上边和左边多余的部分,再加回被减了两次的左上角部分。

完整代码实现

class NumMatrix {

    public int[][] sum;  // 前缀和数组,sum[i][j]表示从(0,0)到(i-1,j-1)的矩形区域和

    public NumMatrix(int[][] matrix) {
        int n = matrix.length;      // 矩阵行数
        int m = matrix[0].length;   // 矩阵列数
        
        // 创建(n+1)×(m+1)的前缀和数组,多一行一列方便处理边界
        sum = new int[n + 1][m + 1];
        
        // 先将原矩阵的值复制到sum数组中,索引偏移1
        for (int a = 1, c = 0; c < n; a++, c++) {
            for (int b = 1, d = 0; d < m; b++, d++) {
                sum[a][b] = matrix[c][d];
            }
        }
        
        // 计算二维前缀和
        // sum[i][j] = 当前元素 + 左边的前缀和 + 上边的前缀和 - 左上角的前缀和(被加了两次需要减去)
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                sum[i][j] += sum[i][j - 1] + sum[i - 1][j] - sum[i - 1][j - 1];
            }
        }
    }

    public int sumRegion(int a, int b, int c, int d) {
        // 将查询坐标转换为前缀和数组的坐标(右下角+1)
        c++;
        d++;
        
        // 利用容斥原理计算矩形区域和:
        // 右下角前缀和 - 上边多余部分 - 左边多余部分 + 左上角重复减去的部分
        return sum[c][d] - sum[c][b] - sum[a][d] + sum[a][b];
    }
}

如果觉得有帮助，欢迎点赞、关注、转发~

差分数组秒杀区间更新问题

Sun, 30 Nov 2025 20:00:00 +0000

求解思路

想象你在管理一排座位的灯光,每次预订就是要把某个区间的灯都调亮一些。

暴力做法是挨个座位去加,但这太慢了。

差分数组的巧妙之处在于:

我们只在区间的起点做个"开始加"的标记,在区间终点的下一个位置做个"停止加"的标记,最后从头到尾扫一遍,遇到"开始加"就累加这个值,遇到"停止加"就把它减掉,这样一路累加下来就得到了每个位置的最终值。

举个例子,要给 2-5 号航班各加 25 个座位,我们只需要在位置 2 标记 +25,在位置 6 标记 -25,然后从前往后累加:

位置 1 是 0,位置 2 是 0+25=25,位置 3 是 25+25=50… 位置 6 是某值-25,这样位置 2-5 都自动累加上了 25,而位置 6 之后又恢复正常。

这个技巧把每次区间更新从逐个修改变成了只改两个端点,效率从 O(n) 提升到 O(1)。

完整代码实现

public class Solution {
    public static int[] corpFlightBookings(int[][] bookings, int n) {
        // 创建差分数组,大小为 n+2 是为了避免边界判断
        // cnt[i] 表示位置 i 相对于位置 i-1 的变化量
        int[] cnt = new int[n + 2];
        
        // 遍历所有预订记录,构建差分数组
        // 每个预订记录对应两个关键操作点
        for (int[] book : bookings) {
            // book[0] 是起始航班(1-indexed)
            // book[1] 是结束航班(1-indexed)
            // book[2] 是预订的座位数
            
            // 在起始位置标记增加 book[2] 个座位
            cnt[book[0]] += book[2];
            
            // 在结束位置的下一个位置标记减少 book[2] 个座位
            // 表示从 book[1]+1 位置开始,这 book[2] 个座位的影响结束
            cnt[book[1] + 1] -= book[2];
        }
        
        // 通过前缀和还原实际值
        // cnt[i] 累加 cnt[i-1] 后,表示第 i 个航班的实际预订座位数
        for (int i = 1; i < cnt.length; i++) {
            cnt[i] += cnt[i - 1];
        }
        
        // 构建最终答案数组
        // 注意:航班编号从 1 开始,所以 cnt[1] 对应答案的 ans[0]
        int[] ans = new int[n];
        for (int i = 0; i < n; i++) {
            ans[i] = cnt[i + 1];  // cnt 数组索引要偏移 1
        }
        
        return ans;
    }
}

如果觉得有帮助，欢迎点赞、关注、转发~

区间和查询-前缀和数组

Sun, 23 Nov 2025 20:05:12 +0000

解题思路

这道题直接暴力求和每次都要遍历区间内所有元素，时间复杂度 O(n)，而前缀和可以将查询优化到 O(1)。

预先计算一个长度为 n+1 的数组 sum（若原数组长度为 n），之所以多一个位置，是为了把 sum[0] 作为“前 0 个元素的和 = 0”占位，这样后续 sum[i] 可以统一表示原数组前 i 个元素之和（注意：sum[i]对应 nums[0]..nums[i-1]）。

构造时从左到右遍历，利用递推关系 sum[i] = sum[i-1] + nums[i-1] 完成预处理。

查询区间 [left, right] 的和时，把区间求和转化为两个前缀和的差值运算，只需要用 sum[right+1] - sum[left] 即可。

代码实现

class NumArray {
    public int[] sum;

    public NumArray(int[] nums) {
        sum = new int[nums.length + 1];
        for (int i = 1; i <= nums.length; i++) {
            sum[i] = sum[i - 1] + nums[i - 1];
        }
    }

    public int sumRange(int left, int right) {
        return sum[right + 1] - sum[left];
    }
}

如果觉得有帮助，欢迎点赞、关注、转发~

求数组中的第K个最大元素

Sat, 04 Oct 2025 11:45:06 +0000

本文采用随机选择算法来解决这道题。

题目要求找到数组 nums 中第 k 大的元素。

我们可以将问题转化为找到数组中第 nums.length - k 小的元素。

1
2
3

	public static int findKthLargest(int[] nums,int k){
		return randomizedSelect(nums,nums.length-k);
	}

选择的核心逻辑

每次随机选一个 pivot，然后做三路划分： • 如果目标索引在左边，就往左区间继续找 • 如果在右边，就往右区间找 • 如果刚好落在等于 pivot 的区域，直接返回

public static int randomizedSelect(int[] arr,int i){
		int ans=0;
		for(int l=0,r=arr.length-1;l<=r;){
			partition(arr,l,r,arr[l+(int)(Math.random()*(r-l+1))]);
			if(i<first){
				r=first-1;
			}else if(i>last){
				l=last+1;
			}else{
				ans = arr[i];
				break;
			}
		}
		return ans;
	}

三路划分

把数组分成三块：

[l, first): 小于 pivot [first, last]: 等于 pivot (last, r]: 大于 pivot

public static void partition(int[] arr, int l, int r, int x) {
    first = l;  // 小于x区域的右边界
    last = r;   // 大于x区域的左边界
    int i = l;
    
    while(i <= last) {
        if(arr[i] == x) {
            i++;  // 等于就跳过
        } else if(arr[i] < x) {
            swap(arr, first++, i++);  // 小于就扔左边
        } else {
            swap(arr, i, last--);     // 大于就扔右边
        }
    }
}

代码链接：https://pan.quark.cn/s/db66ccaf0511 提取码：62Vk

归并排序巧解计算数组的小和问题

Fri, 03 Oct 2025 18:37:41 +0000

这道题如果用暴力的解法，对每一个元素遍历它左边的所有元素，累加比它更小的数，代码逻辑当然非常简单，但是时间复杂度会达到$O(n^2)$，如果数组的长度n达到1e5时，我们估算一下啊，1e10次的运算很明显会超时，这么做会通不过测试系统。

而借助归并排序的思想，是可以将这道题的时间复杂度优化到$O(nlogn)$的。

下面介绍代码逻辑：

1.首先定义全局变量用于存储数据与临时数组

public static int MAXN = 100001;  // 数组最大长度
public static int[] arr = new int[MAXN];  // 存储原始数组
public static int[] help = new int[MAXN];  // 合并时的临时数组
public static int n;  // 数组实际长度

2.输入输出的处理

public static void main(String[] args)throws IOException{
    // 读入
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    StreamTokenizer in = new StreamTokenizer(br);
    // 输出
    PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

    // 处理多组输入（直到文件结束）
    while(in.nextToken()!=StreamTokenizer.TT_EOF){
        n = (int) in.nval;  // 读取数组长度
        // 读取数组元素
        for(int i=0;i<n;i++){
            in.nextToken();
            arr[i]=(int)in.nval;
        }
        // 计算小和并输出
        out.println(smallSum(0,n-1));
    }
    out.flush();  // 刷新缓冲区，确保输出
    out.close();  // 关闭输出流
}

3.分治函数

public static long smallSum(int l,int r){
    if(l==r){  // base case
        return 0;
    }
    int m = l+((r-l)>>1);  // 中间位置，将数组分成 [l,m] 和 [m+1,r]
    // 分治逻辑：左半部分小和 + 右半部分小和 + 合并时的小和
    return smallSum(l,m) + smallSum(m+1,r) + merge(l,m,r);
}

4.合并函数

public static long merge(int l,int m,int r){
    long ans = 0;  // 存储当前合并阶段的小和
    // 统计小和
    for(int j=m+1, i=l, sum=0; j<=r; j++){  
        // 累积左数组 L 中比当前 R[j] 小的元素和
        while(i<=m && arr[i] <= arr[j]){
            sum += arr[i++];
        }
       
        ans += sum;
    }

    // 合并两个有序子数组到 help 数组
    int i = l;        
    int a = l;        
    int b = m+1;      
    while(a <= m && b <= r){  // 两个数组都没遍历完
        // 取较小的元素放入 help
        help[i++] = arr[a] <= arr[b] ? arr[a++] : arr[b++];
    }
    // 处理左数组剩余元素
    while(a <= m){
        help[i++] = arr[a++];
    }
    // 处理右数组剩余元素
    while(b <= r){
        help[i++] = arr[b++];
    }

    // 将 help 中的有序数组拷贝回 arr
    for(i=l; i<=r; i++){
        arr[i] = help[i];
    }

    return ans;  
}

代码链接 链接：小和提取码：2JMV

两种常见的ACM风格笔试题

Tue, 30 Sep 2025 21:27:03 +0000

在算法笔试中，一般有两种风格，一种是填函数风格，可以粗暴地理解为Leetcode中提交的风格，另一种是ACM风格，可以认为是要自己写输入输出的风格，比如华为笔试的风格。

如果是ACM风格，尽量不要使用Scanner、System.out，因为他们的IO效率非常慢。

ACM风格也有两种常见的形式，一种是给定数据规模，另一种是未给定数据规模。

给定数据规模

这道子矩阵的最大累加和问题是一道典型的给定数据规模的题目。

代码

	public static void main(String[] args) throws IOException{
		//将文件中的内容load进内存中
		BufferedReader br  = new BufferedReader(new InputStreamReader(System.in));
		//一个一个读数字
		StreamTokenizer in = new StreamTokenizer(br);
		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
		//文件没有结束就继续
		while(in.nextToken()!=StreamTokenizer.TT_EOF){
			int n = (int)in.nval;
			in.nextToken();
			int m = (int)in.nval;
			int[][] mat = new int[n][m];
			for(int i=0;i<n;i++){
				for(int j = 0;j<m;j++){
					in.nextToken();
					mat[i][j]=(int)in.nval;
				}
			}
			out.println(maxSumSubmatrix(mat,n,m));
		}
		out.flush();
		br.close();
		out.close();
	}
	public static int maxSumSubmatrix(int[][] mat,int n,int m){
		int max = Integer.MIN_VALUE;
		for (int i=0;i<n;i++){
			int[] arr = new int[m];
			for(int j=i;j<n;j++){
				for(int k=0;k<m;k++){
					arr[k]+=mat[j][k];
				}
				max = Math.max(max,maxSumSubarray(arr,m));
			}
		}
		return max;
	}

	public static int maxSumSubarray(int[] arr,int m){
		int max = Integer.MIN_VALUE;
		int cur = 0;
		for(int i=0;i<m;i++){
			cur+=arr[i];
			max=Math.max(max,cur);
			cur = cur<0?0:cur;
		}
		return max;
	}

未给定数据规模

对于没有给定数据规模的ACM风格的笔试题，其实这个时候你想用Scanner也用不了，因为你不知道用户会输入几个数字，所以这个时候可以考虑按行读取。

代码如下：


	// 静态变量：用于存储读取的行和分割后的数字数组
	public static String line;
	public static String[] parts;
	public static int sum;

	public static void main(String[] args) throws IOException {
		// 1. 创建输入流：从标准输入（键盘）读取数据
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		// 2. 创建输出流：向标准输出（控制台）写入数据
		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

		// 3. 循环读取每行数据，直到输入结束（如 Ctrl+D 或文件末尾）
		while ((line = in.readLine()) != null) {
			// 4. 按空格分割当前行，得到数字字符串数组
			parts = line.split(" ");
			sum = 0; // 重置求和变量

			// 5. 遍历数组，将每个字符串转换为整数并累加
			for (String num : parts) {
				sum += Integer.valueOf(num);
			}

			// 6. 输出当前行的求和结果
			out.println(sum);
		}

		// 7. 资源清理：刷新输出流并关闭所有流
		out.flush();
		in.close();
		out.close();
	}

1.BufferedReader 和 PrintWriter 内部维护缓冲区，减少了直接操作磁盘或控制台的次数（IO 操作是程序性能瓶颈之一），尤其在处理大量数据时优势明显。

2.循环读取 line != null 的逻辑适用于各种场景（如读取文件、网络流、控制台输入），只需替换输入流的来源即可复用代码。