string s,t;
    // 在 s 中寻找 t 的「最小覆盖子串」
    int left = 0,right = 0;
    string res = s;
    
    while(right < s.size()) {
        window.add(s[right]);
        right++;
         如果符合要求，说明窗口构造完成，移动 left 缩小窗口
        while (window 符合要求) {
             如果这个窗口的子串更短，则更新 res
            res = minLen(res,window);
            window.remove(s[left]);
            left++;
        }
    }
    return res;

    固定窗口大小为 k
    string s;
     在 s 中寻找窗口大小为 k 时的所包含最大元音字母个数
    int  right = 0; 如果符合要求，说明窗口构造完成，
        if (right>=k) {
             这是已经是一个窗口了，根据条件做一些事情
            ... 可以计算窗口最大值等 
             最后不要忘记把 right -k 位置元素从窗口里面移除
        }
    }
    return res;    

输入：s = "abcd",t = "bcdf",cost = 3
输出：3
解释：s 中的 "abc" 可以变为 "bcd"。开销为 3，所以最大长度为 3。

输入：s = "abcd",t = "cdef",1)">
输出：1
解释：s 中的任一字符要想变成 t 中对应的字符，其开销都是 2。因此，最大长度为 1。

输入：s = "abcd",t = "acde",cost = 0
解释：你无法作出任何改动，所以最大长度为 1。?

class Solution {
    public int equalSubstring(String s,String t,int maxCost) {
        int sum = 0int res = 0;
　　　　 // 构造窗口
        while (right < s.length()) {
            sum += Math.abs(s.charAt(right) - t.charAt(right));
            right++　　　　　　　// 窗口构造完成，这时候要根据条件当前的窗口调整窗口大小
            while (sum > maxCost) {
                sum -=  Math.abs(s.charAt(left) - t.charAt(left));
                left++;
            }
　　　　　　　// 记录此时窗口的大小
            res = Math.max(res,right -left);
        }
        return res;
    }
}

输入: nums = [1,3,-1,-3,5,6,7],和 k = 3
输出: [3,7] 
解释: 

  滑动窗口的位置                最大值
---------------               -----
[1  3  -1] -3  5  3  6  7       3
 1 [3  -1  -3] 5  3  6  7       3
 1  3 [-1  -3  5] 3  6  7       5
 1  3  -1 [-3  5  3] 6  7       5
 1  3  -1  -3 [5  3  6] 7       6
 1  3  -1  -3  5 [3  6  7]      7

1 <= nums.length <= 10^5
-10^4 <= nums[i] <= 10^4
1 <= k <= nums.length

static int[] maxSlidingWindow(int[] nums,1)"> k) {
        int right =0int[] res = new int[nums.length -k +1];
        int index=0;
        LinkedList<Integer> list = new LinkedList<>();
　　　　　// 开始构造窗口
         nums.length) {
　　　　　　　// 这里的list的首位必须是窗口中最大的那位
            while (!list.isEmpty() && nums[right] > list.peekLast()) {
                list.removeLast();
            }
　　　　　　　// 不断添加
            list.addLast(nums[right]);
            right++　　　　　　　// 构造窗口完成，这时候需要根据条件做一些操作
            if (right >= k){
                res[index++]=list.peekFirst();
　　　　　　　　　　// 如果发现第一个已经在窗口外面了，就移除
                if(list.peekFirst() == nums[right-k]) {
                    list.removeFirst();
                }
            }
        }
         res;
    }
}?

输入：s = "abciiidef",k = 3
解释：子字符串 "iii" 包含 3 个元音字母。

输入：s = "aeiou",k = 2
输出：2
解释：任意长度为 2 的子字符串都包含 2 个元音字母。

输入：s = "leetcode",1)">
解释："lee"、"eet" 和 "ode" 都包含 2 个元音字母。

输入：s = "rhythms",k = 4
输出：0
解释：字符串 s 中不含任何元音字母。

输入：s = "tryhard",1)">
输出：1

1 <= s.length <= 10^5
s 由小写英文字母组成
1 <= k <= s.length

int maxVowels(String s,1)">int max = 0 s.length()) {
            sum += isYuan(s.charAt(right)) ;
            right++;
            k) {
                max = Math.max(max,sum);
                sum -= isYuan(s.charAt(right-k));
            }
        }
         max;
    }

    int isYuan(char s) {
        return s=='a' || s=='e' ||s=='i' ||s=='o' ||s=='u' ? 1:0;
    }
}