数组元素平方和计算遇多最大值递减异常，求技术解决方案

我明白你遇到的坑了——当数组里有多个相同的最大值时，你的当前代码只会死盯着第一个出现的最大值不停减1，其他的最大值元素完全没被处理，导致最终计算的平方和肯定不对，对吧？

咱们先拆解下问题根源：你原来找最大值索引的逻辑，只有当后面的元素严格大于当前最大值时才更新索引，所以多个相同最大值的情况下，索引永远停留在第一个最大值的位置，每次只改它一个，其他最大值纹丝不动。

下面给你两种针对性的解决方案，看哪种更符合你的需求：

方案1：每次循环处理一个最大值（轮流覆盖所有最大值） #

如果你希望每次迭代只减一个最大值元素，但要公平地处理所有的最大值（比如这次减第一个，下次减第二个），可以修改逻辑，先收集所有最大值的位置，再按顺序选择处理：

import java.util.ArrayList;
import java.util.List;
import java.util.Arrays;

class NoOvertime {
    public int noOvertime(int no, int[] works) {
        int sum = 0;
        // 改成no>0更直观，代表剩余可执行的操作次数
        while (no > 0) { 
            int max = Arrays.stream(works).max().getAsInt();
            // 收集所有最大值的索引
            List<Integer> maxIndices = new ArrayList<>();
            for (int i = 0; i < works.length; i++) {
                if (works[i] == max) {
                    maxIndices.add(i);
                }
            }
            // 每次选择第一个最大值索引减1（也可以随机选，按需调整）
            int targetIndex = maxIndices.get(0);
            works[targetIndex]--;
            no--;
        }
        // 计算平方和
        for (int num : works) {
            sum += num * num;
        }
        return sum;
    }

    public static void main(String[] args) {
        NoOvertime solution = new NoOvertime();
        int[] works = {3, 3};
        System.out.println(solution.noOvertime(2, works)); // 输出 8（2²+2²）
    }
}

这个方案每次会重新扫描所有最大值的位置，确保不会一直盯着同一个元素减1，能公平处理所有峰值。

方案2：每次循环处理所有最大值 #

如果你希望每次迭代把数组中所有的最大值元素都减1（比如一次操作抹平所有峰值），逻辑会更简单，直接遍历数组批量处理：

import java.util.Arrays;

class NoOvertime {
    public int noOvertime(int no, int[] works) {
        int sum = 0;
        while (no > 0) {
            int max = Arrays.stream(works).max().getAsInt();
            // 遍历数组，把所有等于最大值的元素减1
            for (int i = 0; i < works.length; i++) {
                if (works[i] == max) {
                    works[i]--;
                }
            }
            no--;
        }
        // 计算平方和
        for (int num : works) {
            sum += num * num;
        }
        return sum;
    }

    public static void main(String[] args) {
        NoOvertime solution = new NoOvertime();
        int[] works = {3, 3};
        System.out.println(solution.noOvertime(1, works)); // 输出 8（2²+2²）
    }
}

这个方案适合需要一次性降低所有峰值的场景，效率也更高，不需要额外收集索引。

另外提个小细节：你的原代码while条件写的是no>-1，改成no>0会更直观，因为no代表的是可执行的操作次数，每次循环消耗一次，直到次数用完为止。

内容的提问来源于stack exchange，提问作者NSN7