力扣第354次周赛Java版（小白角度思路）

第一题，简单题，直接用暴力做出来吧，根据题意判断一下符合条件，然后直接对元素的平方累积求和。

class Solution {
    public int sumOfSquares(int[] nums) {
        int sum = 0;
        int n = nums.length;
        for(int i = 1; i <= n; i++){
            if(n % i == 0){
                sum += nums[i-1] * nums[i-1];
            }
        }
        return sum;
    }
}

第二题，刚开始看没有思路，以为要用动规（太菜了）然后换了个号看看有没有人有讨论的思路。结果是同向双指针，并且需要注意的是每个下标都可以进行一次加减k的操作。这个时候就可以转化为要进行比较的数之间的差在2k就行了。同时可以方便一点先排序再比较。

（不会用差分数组的方法）

class Solution {
    public int maximumBeauty(int[] nums, int k) {
        int n = nums.length;
        Arrays.sort(nums);
        int max = 0;
        int left = 0;
        int right = 0;
        for(;right < n; right++){
            if(nums[left] < nums[right] - 2 * k){
                left++;
            }
        max = Math.max(right - left + 1,max);
        }
        return max;

    }
}

第三题，也需要自己先把题目中的逻辑捋顺然后写出关系式，进行化简。

（摘自讨论区），主要的就是数学关系，这点小白要养成看题目写公式的习惯，尤其是数组，这次我是学到了，刷了500题了，数组和字符串就会些明显的方法了，稍微绕点弯就不回了，太残酷了。

所以代码如下 

class Solution {
    public int minimumIndex(List<Integer> nums) {

        HashMap<Integer,Integer> map = new HashMap<>();
        int max_count = 0;
        int zhipei = 0;
        for(int num : nums){
            map.put(num,map.getOrDefault(num,0) + 1);

            if(map.get(num) > max_count){
                zhipei = num;
                max_count = map.get(num);
            }
        }
        int count = 0;
        if(map.get(zhipei) * 2 < nums.size()) return -1; 
        for(int i = 0; i < nums.size(); i++){
            if(nums.get(i) == zhipei){
                count++;
            }
            if(count * 2 > i + 1 && (map.get(zhipei) - count)* 2 > nums.size() - i - 1){
                return i;
            } 
        }
        return -1;
    }
}

第四题，暴力法，暂时没有怎么弄懂，跟着大佬写了个java版本的

class Solution {
    public int longestValidSubstring(String word, List<String> forbidden) {
        HashSet<String> set = new HashSet<>();
        for(String s : forbidden){
            set.add(s);
        }
        int max = 0;
        int end = word.length();
        for(int i = end-1; i >= 0; i--){
            //因为substring特性，这里j需要等于结束长度。
            for(int j = i+1; j <= Math.min(i + 10,end); j++){
                if(set.contains(word.substring(i,j))){
                    end = j - 1;
                    break;
                } 
            }
                 max = Math.max(end - i,max);
        }
        return max;
    }
}