第一题是比较简单的滑动窗口题目

java
class Solution {
    public int maxSatisfied(int[] customers, int[] grumpy, int minutes) {
        int n = customers.length;
        int totalSatisfied = 0;
        int maxExtraSatisfied = 0;
        int currentExtraSatisfied = 0;

        // 计算不使用秘密技巧时的最大满意客户数量
        for (int i = 0; i < n; i++) {
            if (grumpy[i] == 0) {
                totalSatisfied += customers[i];
            }
        }

        // 使用滑动窗口找到使用秘密技巧后可以额外满足的最大客户数量
        for (int i = 0; i < n; i++) {
            currentExtraSatisfied += grumpy[i] == 1 ? customers[i] : 0; //累加
            if (i >= minutes) { // 超过窗口大小
                currentExtraSatisfied -= grumpy[i - minutes] == 1 ? customers[i - minutes] : 0; // 减去前面部分
            }
            maxExtraSatisfied = Math.max(maxExtraSatisfied, currentExtraSatisfied);
        }

        return totalSatisfied + maxExtraSatisfied;
    }
}

第二题求符合条件的最小窗口

java
class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int n = nums.length;
        int left = 0, right = 0, sum = 0, ans = Integer.MAX_VALUE;
        while (right < n) {
            sum += nums[right];
            while (sum >= target) {
                ans = Math.min(ans, right - left + 1);
                sum -= nums[left];
                left++;
            }
            right++;
        }
        return ans == Integer.MAX_VALUE ? 0 : ans;
    }
}

第三题可以用哈希表来达到O(N)

java
class Solution {
    public boolean containsNearbyDuplicate(int[] nums, int k) {
        Map<Integer, Integer> seen = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            if (seen.containsKey(nums[i]) && i - seen.get(nums[i]) <= k) {
                return true;
            }
            seen.put(nums[i], i);
        }
        return false;
    }
}

第四题也是道简单题

java
class Solution {
    public double findMaxAverage(int[] nums, int k) {
        int sum = 0, maxSum = Integer.MIN_VALUE;
        for (int i = 0; i < k; i++) {
            sum += nums[i];
        }
        maxSum = sum;
        double maxAvg = (double) sum / k;
        for (int i = k; i < nums.length; i++) {
            sum = sum - nums[i - k] + nums[i];
            if (sum > maxSum) {
                maxSum = sum;
                maxAvg = (double) sum / k;
            }
        }
        return maxAvg;
    }
}

第五题也是一道能用滑动窗口，思路简单，也有dp解法

java

class Solution {
    public int findLength(int[] nums1, int[] nums2) {
        return Math.max(maxLen(nums1,nums2),maxLen(nums2,nums1));
    }
    public int maxLen(int[] nums1,int[] nums2){
        int ans=0;
        for(int i=0;i<nums1.length;i++){
            int max=0;
            int temp=0;
            for(int j=0;j<nums2.length&&i+j<nums1.length;j++){
                if(nums1[j+i]==nums2[j])
                    temp++;
                else
                    temp=0;
                max=Math.max(temp,max);
            }
            ans=Math.max(max,ans);
        }
        return ans;
    }
}


// dp

class Solution {
    public int maxLength(int[] nums1, int[] nums2) {
        int m = nums1.length, n = nums2.length;
        int[][] dp = new int[m + 1][n + 1];
        int maxLength = 0;
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (nums1[i - 1] == nums2[j - 1]) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                    maxLength = Math.max(maxLength, dp[i][j]);
                }
            }
        }
        return maxLength;
    }
}