是滑动窗口的5.25

• 滑动窗口-总结
• • 本章的启发（467. 环绕字符串中唯一的子字符串）
  • • 题解
  • 1984. 学生分数的最小差值
  • • 个人解法
    • 官方解法
  • 594. 最长和谐子序列
  • • 个人解法
    • 官方解法
  • 643. 子数组最大平均数 I
  • • 个人解法
    • 官方解法
  • Offer II 008. 和大于等于 target 的最短子数组
  • • 个人解法

滑动窗口总结：
所谓滑动，就是双指针的另一种应用。-5.25
一个大小可变的窗口，左右两端方向一致的向前滑动（右端固定，左端滑动；左端固定，右端滑动）。

//滑动窗口范例
for( point1){
    while(point2){
        进行判断;
    }
}

// 负雪明烛 https://leetcode.cn/problems/unique-substrings-in-wraparound-string/solution/by-fuxuemingzhu-ixas/
//Gnakuw   https://leetcode.cn/problems/unique-substrings-in-wraparound-string/solution/by-nehzil-mkcg/

遇到子串，一般会想到「滑动窗口」和「动态规划」。
本地的思想其实是「滑动窗口」和「动态规划」相结合。
子串相关的动态规划，一般状态的定义都是「以位置 ii 作为结尾的、符合要求的子串长度」。

class Solution {
    public int findSubstringInWraproundString(String p) {
        int[] dp = new int[26];
        int k = 0;
        for (int i = 0; i < p.length(); ++i) {
        //判断是否连续，不连续就重开;
            if (i > 0 && (p.charAt(i) - p.charAt(i - 1) + 26) % 26 == 1) { // 字符之差为 1 或 -25
                ++k;
            } else {
                k = 1;
            }
            dp[p.charAt(i) - 'a'] = Math.max(dp[p.charAt(i) - 'a'], k);
        }
        //将所有增量累加，就是非空子串的数量
        //Java中Arrays类的stream(T [] array)方法用于从作为参数传递的数组及其元素中获取顺序流。它返回一个顺序的Stream，它具有作为参数传递的数组元素作为其源。
        return Arrays.stream(dp).sum();
    }
}

class Solution {
    public int minimumDifference(int[] nums, int k) {
        Arrays.sort(nums);
        // 这里gap   = Integer.MAX_VALUE;
        int gap = 1000000000;
        int i = 0;
        while(i<=nums.length-k){
            if(nums[k+i-1]-nums[i]
                gap = nums[k+i-1]-nums[i];
            }
            i++;
        }
        return gap;
    }
}

class Solution {
    public int minimumDifference(int[] nums, int k) {
        int n = nums.length;
        Arrays.sort(nums);
        int ans = Integer.MAX_VALUE;
        for (int i = 0; i + k - 1 < n; ++i) {
            ans = Math.min(ans, nums[i + k - 1] - nums[i]);
        }
        return ans;
    }
}

// 作者：LeetCode-Solution

class Solution {
    public int findLHS(int[] nums) {
    
    Arrays.sort(nums);
    int gap = 0;
    int i = 0;
    Map map = new HashMap<>();
    for(int j=0; j
//这里可以用map.put(i,map.getOrDefault(i,0)+1)来进行升级

        if(map.get(nums[j])==null){
            map.put(nums[j], 1);
        }else{
            map.put(nums[j], map.get(nums[j])+1);
        }
    }
//map.getcontainsKey
    while(i
        if(nums[i+1]-nums[i]==1){
            if(gap < map.get(nums[i]) + map.get(nums[i+1]))
            gap=map.get(nums[i]) + map.get(nums[i+1]);
        }
        i++;
    }
    return gap;
    }
}

class Solution {
    public int findLHS(int[] nums) {
        Arrays.sort(nums);
        int n = nums.length, ans = 0;
        for (int i = 0, j = 0; j < n; j++) {
            while (i < j && nums[j] - nums[i] > 1) i++;
            if (nums[j] - nums[i] == 1) ans = Math.max(ans, j - i + 1);
        }
        return ans;
    }
}

class Solution {
    public int findLHS(int[] nums) {
        Map map = new HashMap<>();
        for (int i : nums) map.put(i, map.getOrDefault(i, 0) + 1);
        int ans = 0;
        for (int i : nums) {
            if (map.containsKey(i - 1)) {
                ans = Math.max(ans, map.get(i) + map.get(i - 1));
            }
        }
        return ans;
    }
}

class Solution {
    public double findMaxAverage(int[] nums, int k) {
        //  = Double.MIN_VALUE;
        int res = 0;
         for (int i = 0; i < k; i++) {
            res += nums[i];
        }
        for(int j=0; j
            int sum = 0;
            int i = j;
            while( i    
                sum += nums[i];
                i++;
            }
            res = Math.max(res, sum);
        }
        return 1.0 * res/k;
    }
}

class Solution {
    public double findMaxAverage(int[] nums, int k) {
        int sum = 0;
        int n = nums.length;
        for (int i = 0; i < k; i++) {
            sum += nums[i];
        }
        int maxSum = sum;
        for (int i = k; i < n; i++) {
            sum = sum - nums[i - k] + nums[i];
            maxSum = Math.max(maxSum, sum);
        }
        return 1.0 * maxSum / k;
    }
}

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        List list = new ArrayList<>();
        if(Arrays.stream(nums).sum() < target) return 0;
        for(int i=0; i
            int j = i+1;
            int sum = nums[i];
            if(sum>=target)return 1;
            while(j
                sum += nums[j]; 
                if(sum>=target) {
                    list.add(j-i+1);
                    break;
                }
                j++;
            }
        }
        int min = Integer.MAX_VALUE;
        for(int i=0; i