| 关卡名 | 滑动窗口高频问题 | 我会了✔️ |
| 内容 | 1.掌握最长子串问题 | ✔️ |
| 2.理解长度最小的子数组问题 | ✔️ | |
| 3.掌握盛水最多的容器问题 | ✔️ | |
| 4.理解异位词问题如何解决 | ✔️ |
1 最长子串专题
先来看一道高频算法题：无重复字符的最长子串。具体要求是给定一个字符串 s ，请你找出其中不含有重复字符的最长子串的长度。例如，输入: s = "abcabcbb" 则输出3，因为无重复字符的最长子串是 "abc"，所以其长度为3。
怎么做后面再说，如果再变一下要求，至多包含两个不同字符的最长子串，该怎么做呢？
再变一下要求，至多包含 K 个不同字符的最长子串，该怎么做呢？
到这里是否感觉，这不在造题吗？是的！上面就分别是LeetCode3、159、340题，而且这几道题都可以用滑动窗口来解决。学会之后，我们就总结出滑动窗口的解题模板了。
接下来，我们就一道一道看。
1.1 无重复字符的最长子串
LeetCode3 给定一个字符串 s ，请你找出其中不含有重复字符的最长子串的长度。例如：
输入: s = "abcabcbb"
输出: 3
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
要找最长子串，必然要知道无重复字符串的首和尾，然后再从中确定最长的那个，因此至少两个指针才可以，这就想到了滑动窗口思想。即使使用滑动窗口，深入分析会发现具体处理起来有多种方式。这里介绍一种经典的使用Map的思路。
我们定义一个K-V形式的map，key表示的是当前正在访问的字符串，value是其下标索引值。我们每访问一个新元素，都将其下标更新成对应的索引值。具体过程如下图：
如果是已经出现过的，例如上述示例中的 abcabc，当第二次遇到a时，我们就更新left成为第一个b所在的位置，此时惊奇的发现left要移动的位置恰好就是map.get(’a‘) + 1=1，我们将'a'用序列来表示，放在一起就是map.get(s.charAt(i)) + 1。其他情况可以参考图示依次类推。
有一种特殊情况我们需要考虑，例如abba，我们第二次访问b时，left=map.get(’b‘) + 1=2。
然后继续访问第二个a，此时left=map.get(’a‘) + 1=1，也就是left后退了，显然不对。
我们应该让left在2的基础上继续向前，那该怎么办呢？和原来的对比一下，将最大的加1就可以了，也就是：
left = Math.max(left,map.get(s.charAt(i)) + 1);
完整的代码如下：
public int lengthOfLongestSubstring(String s) {
if (s.length() == 0) return 0;
HashMap<Character, Integer> map = new HashMap<Character, Integer>();
int max = 0;
int left = 0;
for (int right = 0; right < s.length(); right++) {
if (map.containsKey(s.charAt(right))) {
left = Math.max(left, map.get(s.charAt(right)) + 1);
}
map.put(s.charAt(right), right);
max = Math.max(max, right - left + 1);
}
return max;
}除了上述方法，不用Hash存储索引，也可以用滑动窗口思想来解决，感兴趣的可以研究一下。
1.2 至多包含两个不同字符的最长子串
给定一个字符串 s ，找出 至多 包含两个不同字符的最长子串 t ，并返回该子串的长度，这就是LeetCode159题。例如：
输入: "eceba"
输出: 3
解释: t 是 "ece"，长度为3。
我们仍然使用left和right来锁定一个窗口，然后一边向右移动一边分析。我们用一个序列来看一下：aabbcccd。
我们接下来需要解决两个问题，一个是怎么判断只有2个元素，另一个是移除的时候怎么知道移除谁，以及移除之后left是什么。
要判断只有2个元素，还是Hash好用，每一个时刻，这个 hashmap 包括不超过 3 个元素。这里还要考虑到要移除谁，所以我们要设计一下Hash的Key-Value的含义。我们把字符串里的字符都当做键，在窗口中的最右边的字符位置作为值。此时使用下面的代码就可以确定要删除谁，以及窗口left的新位置：
伪码，从Hash中找最小值
del_idx = Collections.min(hashmap.values());
left = del_idx + 1;
为什么呢？我们还是画图看一下：
所以我们可以充分利用Map的工具来解决该问题：
public int lengthOfLongestSubstringTwoDistinct(String s) {
if (s.length() < 3) {
return s.length();
}
int left = 0, right = 0;
HashMap<Character, Integer> hashmap = new HashMap<>();
int maxLen = 2;
while (right < s.length()) {
if (hashmap.size() < 3)
hashmap.put(s.charAt(right), right++);
// 如果大小达到了3个
if (hashmap.size() == 3) {
// 最左侧要删除的位置
int del_idx = Collections.min(hashmap.values());
hashmap.remove(s.charAt(del_idx));
// 窗口left的新位置
left = del_idx + 1;
}
maxLen = Math.max(maxLen, right - left);
}
return maxLen;
}1.3 至多包含 K 个不同字符的最长子串
如果再提高一下难度， 至多包含 K 个不同字符的最长子串该怎么办呢？这就是LeetCode340题。
题目的完整要求是：给定一个字符串 s，找出 至多 包含 k 个不同字符的最长子串T。示例：
输入: s = "eceba", k = 2
输出: 3
解释: 则 T 为 "ece"，所以长度为 3。
本题与上面的题几乎没有区别，只要将判断hash大小为2改成k就可以，超过2就是k+1。十分钟实现：
public int lengthOfLongestSubstringKDistinct(String s, int k) {
if (s.length() < k + 1) {
return s.length();
}
int left = 0, right = 0;
HashMap<Character, Integer> hashmap = new HashMap<>();
int maxLen = k;
while (right < s.length()) {
if (hashmap.size() < k + 1)
hashmap.put(s.charAt(right), right++);
// 如果大小达到了k个
if (hashmap.size() == k + 1) {
int del_idx = Collections.min(hashmap.values());
hashmap.remove(s.charAt(del_idx));
// 窗口left的新位置
left = del_idx + 1;
}
maxLen = Math.max(maxLen, right - left);
}
return maxLen;
}2 长度最小的子数组
LeetCode209.长度最小的子数组,给定一个含有 n 个正整数的数组和一个正整数 target 。
找出该数组中满足其和 ≥ target 的长度最小的 连续子数组 [numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。
输入：target = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3] 是该条件下的长度最小的子数组。
本题可以使用双指针来解决，也可以视为队列法，基本思路是先让元素不断入队，当入队元素和等于target时就记录一下此时队列的容量，如果队列元素之和大于target则开始出队， 直到小于target则再入队。
如果出现等于target的情况，则记录一下此时队列的大小，之后继续先入队再出队。每当出现元素之和等于target时我们就保留容量最小的那个。
实现代码如下：
public int minSubArrayLen(int target, int[] nums) {
int left = 0, right = 0, sum = 0, min = Integer.MAX_VALUE;
while (right < nums.length) {
sum += nums[right++];
while (sum >= target) {
min = Math.min(min, right - left);
sum -= nums[left++];
}
}
return min == Integer.MAX_VALUE ? 0 : min;
}3. 盛水最多的容器
LeetCode11.给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。返回容器可以储存的最大水量。
示例：
输入：[1,8,6,2,5,4,8,3,7]
输出：49
解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。
本题看似复杂，但其实简单的很。设两指针 i , j ，指向的水槽板高度分别为 h[i] , h[j] ，此状态下水槽面积为S(i,j) 。由于可容纳水的高度由两板中的 短板 决定，因此可得如下面积公式 ：
S(i,j)=min(h[i],h[j])×(j−i)
在每个状态下，无论长板或短板向中间收窄一格，都会导致水槽底边宽度−1 变短：
- 若向内移动短板 ，水槽的短板min(h[i],h[j]) 可能变大，因此下个水槽的面积可能增大 。
- 若向内移动长板 ，水槽的短板min(h[i],h[j]) 不变或变小，因此下个水槽的面积一定变小 。
因此，只要初始化双指针分列水槽左右两端，循环每轮将短板向内移动一格，并更新面积最大值，直到两指针相遇时跳出；即可获得最大面积。
public int maxArea(int[] height) {
int i = 0, j = height.length - 1, res = 0;
while(i < j) {
res = height[i] < height[j] ?
Math.max(res, (j - i) * height[i++]):
Math.max(res, (j - i) * height[j--]);
}
return res;
}4 寻找子串异位词（排列）
如果两个字符串仅仅是字母出现的位置不一样，则称两者相互为对方的一个排列，也称为异位词。
如果判断两个字符串是否互为排列，是字符串的一个基本算法。现在我们给增加难度。看LeetCode567和438两个题。
4.1 字符串的排列
LeetCode567.给你两个字符串s1和s2 ，写一个函数来判断 s2是否包含 s1的排列。如果是，返回 true ；否则，返回 false 。换句话说，s1 的排列之一是 s2 的子串 。其中s1和s2都只包含小写字母。
示例：
输入：s1 = "ab" s2 = "eidbaooo"
输出：true
解释：s2 包含 s1 的排列之一 ("ba").
本题因为字符串s1的异位词长度一定是和s2字符串的长度一样的，所以很自然的想到可以以s1.length()为大小截图一个固定窗口，然后窗口一边向右移动，一边比较就行了。此时可以将窗口内的元素和s1先做一个排序，然后再比较即可，但是这样做的问题是排序代价太高了，我们需要考虑性能更优的方法。
所谓的异位词不过两点：字母类型一样，每个字母出现的个数也是一样的。题目说s1和s2都仅限小写字母，因此我们可以创建一个大小为26的数组，每个位置就存储从a到z的个数，为了方便操作，索引我们使用
index=s1.charAt(i) - 'a'
来表示，这是处理字符串的常用技巧。
此时窗口的right向右移动就是执行：
charArray2[s2.charAt(right) - 'a']++;
而left向右移动就是执行：
伪码：
int left = right - sLen1;
charArray2[s2.charAt(left) - 'a']--;
所以，完整代码如下：
public boolean checkInclusion(String s1, String s2) {
int sLen1 = s1.length(), sLen2 = s2.length();
if (sLen1 > sLen2) {
return false;
}
int[] charArray1 = new int[26];
int[] charArray2 = new int[26];
for(int i=0;i<sLen1;i++){
++charArray1[s1.charAt[i]-'a'];
++charArray2[s2.charAt[i]-'a'];
}
if (Arrays.equals(charArray1, charArray2)) {
return true;
}
for(int right=sLen1;right<sLen2;right++){
charArray2[s2.charAt(right)-'a']++;
int left=right-sLen2;
charArray2[s2.charAt(left)-'a']--;
if (Arrays.equals(charArray1, charArray2)) {
return true;
}
}
return false;
}上面只是判断有没有，那如果让你确定一下有几个呢？有或者如果有的话，将异位词的开始位置输出出来怎么做呢？这就是LeetCode438题。
4.2 找到字符串中所有字母异位
LeetCode438.找到字符串中所有字母异位词，给定两个字符串 s 和 p，找到 s 中所有 p 的 异位词 的子串，返回这些子串的起始索引。不考虑答案输出的顺序。注意s和p仅包含小写字母。
异位词 指由相同字母重排列形成的字符串（包括相同的字符串）。例如：
输入: s = "cbaebabacd", p = "abc"
输出: [0,6]
解释:
起始索引等于 0 的子串是 "cba", 它是 "abc" 的异位词。
起始索引等于 6 的子串是 "bac", 它是 "abc" 的异位词。
本题的思路和实现与上面几乎一模一样，唯一不同的是需要用一个List，如果出现异位词，还要记录其开始位置，那直接将其add到list中就可以了。完整代码：
public List<Integer> findAnagrams(String s, String p) {
int sLen = s.length(), pLen = p.length();
if (sLen < pLen) {
return new ArrayList<Integer>();
}
List<Integer> ans = new ArrayList<Integer>();
int[] sCount = new int[26];
int[] pCount = new int[26];
//先分别初始化两个数组
for (int i = 0; i < pLen; i++) {
sCount[s.charAt(i) - 'a']++;
pCount[p.charAt(i) - 'a']++;
}
if (Arrays.equals(sCount, pCount)) {
ans.add(0);
}
for (int left = 0; left < sLen - pLen; left++) {
sCount[s.charAt(left) - 'a']--;
int right=left + pLen;
sCount[s.charAt(right) - 'a']++;
if (Arrays.equals(sCount, pCount)) {
//上面left多减了一次，所以
ans.add(left + 1);
}
}
return ans;
}
