滑动窗口经典问题(算法村第十六关白银挑战)
最长字串专题
无重复字符的最长子串
3. 无重复字符的最长子串 - 力扣（LeetCode）
给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。
示例 1:
输入: s = "abcabcbb"
输出: 3
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
示例 2:
输入: s = "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
示例 3:
输入: s = "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。
提示：
0 <= s.length <= 5 * 104s由英文字母、数字、符号和空格组成
滑动窗口+HashMap
start不动，end向后移动- 当
end遇到重复字符时，若重复字符的上一个位置比start靠右，则start更新为重复字符的上一个位置 + 1（即子串从不重复的位置重新开始统计）。同时记录最长字串的长度 - hashMap的
key记录字符，value记录重复字符的最新下标。
public int lengthOfLongestSubstring(String s)
{
int start = 0;
int ans = 0;
HashMap<Character, Integer> hashMap = new HashMap<Character, Integer>();
for (int end= 0; end < s.length(); end++)
{
char c = s.charAt(end);
if ((hashMap.containsKey(c)))
start = Math.max(hashMap.get(c) + 1, start);
hashMap.put(c, end);
ans = Math.max(ans, end - start + 1);
}
return ans;
}
参考题解：3. 无重复字符的最长子串 - 力扣（LeetCode）
至多包含两个不同字符的最长子串
159. 至多包含两个不同字符的最长子串 - 力扣（LeetCode）
给你一个字符串 s ，请你找出 至多 包含 两个不同字符 的最长子串，并返回该子串的长度。
示例 1：
输入：s = "eceba"
输出：3
解释：满足题目要求的子串是 "ece" ，长度为 3 。
示例 2：
输入：s = "ccaabbb"
输出：5
解释：满足题目要求的子串是 "aabbb" ，长度为 5 。
基于HashMap的滑动窗口
public int lengthOfLongestSubstringTwoDistinct(String s)
{
if (s.length() < 3)
return s.length();
// hashMap 中的字符 -> 字符在滑动窗口中最靠右的位置
HashMap<Character, Integer> hashMap = new HashMap<Character, Integer>();
int ans = 2;
for (int left = 0, right = 0; right < s.length(); right++)
{
hashMap.put(s.charAt(right), right);
//滑动窗口中不同字符超过2个(应维持在2个及以内)
if(hashMap.size() > 2)
{
//提取滑动窗口中最靠左的字符的位置
int t = Collections.min(hashMap.values());
//删除在滑动窗口中删除该字符
hashMap.remove(s.charAt(t));
//更新滑动窗口中左侧指针
left = t + 1;
}
ans = Math.max(ans, right - left + 1);
}
return ans;
}
参考题解：159. 至多包含两个不同字符的最长子串 - 力扣（LeetCode）
拓展题
340. 至多包含 K 个不同字符的最长子串 - 力扣（LeetCode）
给你一个字符串 s 和一个整数 k ，请你找出 至多 包含 k 个 不同 字符的最长子串，并返回该子串的长度。
public int lengthOfLongestSubstringKDistinct(String s, int k)
{
if (s.length() < k)
return s.length();
// hashMap 中的字符 -> 字符在滑动窗口中最靠右的位置
HashMap<Character, Integer> hashMap = new HashMap<Character, Integer>();
int ans = k;
for (int left = 0, right = 0; right < s.length(); right++)
{
hashMap.put(s.charAt(right), right);
//滑动窗口中不同字符超过k个(应维持在k个及以内)
if(hashMap.size() > k)
{
//提取滑动窗口中最靠左的字符的位置
int t = Collections.min(hashMap.values());
//删除在滑动窗口中删除该字符
hashMap.remove(s.charAt(t));
//更新滑动窗口中左侧指针
left = t + 1;
}
ans = Math.max(ans, right - left + 1);
}
return ans;
}
长度最小的子数组
209. 长度最小的子数组 - 力扣（LeetCode）
给定一个含有 n 个正整数的数组和一个正整数 target 。
找出该数组中满足其总和大于等于 target 的长度最小的 连续子数组 [numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度**。**如果不存在符合条件的子数组，返回 0 。
示例 1：
输入：target = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3] 是该条件下的长度最小的子数组。
示例 2：
输入：target = 4, nums = [1,4,4]
输出：1
示例 3：
输入：target = 11, nums = [1,1,1,1,1,1,1,1]
输出：0
提示：
1 <= target <= 1091 <= nums.length <= 1051 <= nums[i] <= 105
大小可变的滑动窗口
这里用队列的结构来演示
public int minSubArrayLen(int target, int[] nums)
{
int ans = Integer.MAX_VALUE;
int sum = 0;
for (int left = 0, right = 0; right < nums.length; right++)
{
//滑动窗口向右延伸
sum += nums[right];
//窗口中所有元素之和>=target时，记录长度，并收缩窗口左侧
while (sum >= target)
{
ans = Math.min(ans, right - left + 1);
//收缩
sum -= nums[left];
left++;
}
}
//存在[nums的所有元素之和 < target]的情况，这种情况下ans无法更新
return ans == Integer.MAX_VALUE ? 0 : ans;
}
盛最多水的容器
11. 盛最多水的容器 - 力扣（LeetCode）
给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。
找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。
返回容器可以储存的最大水量。
**说明：**你不能倾斜容器。
示例 1：
输入：[1,8,6,2,5,4,8,3,7]
输出：49
解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。
示例 2：
输入：height = [1,1]
输出：1
提示：
n == height.length2 <= n <= 1050 <= height[i] <= 104
向内收缩
盛水容量(面积) = 短板高度 * 两板距离。初始化一个板在最左，一个板在最右。向内收缩的过程中，两板距离一定减小，收缩短板一侧可能使短板变长板，原来的长板成为新的短板，从而使面积增大；但收缩长板一侧并不能改变原来的短板，甚至可能会使长板变短板，导致面积进一步减小。
所以我们只有在遍历的过程中，不断收缩短板一侧即可，同时记录最大盛水容量（面积）
public int maxArea(int[] height)
{
int left = 0, right = height.length - 1;
int area = 0;
while (left < right)
{
area = height[left] < height[right] ?
Math.max(area, (right - left) * height[left++]) :
Math.max(area, (right - left) * height[right--]);
}
return area;
}
寻找字串异位词
字符串的排列
567. 字符串的排列 - 力扣（LeetCode）
给你两个字符串 s1 和 s2 ，写一个函数来判断 s2 是否包含 s1 的排列。如果是，返回 true ；否则，返回 false 。
换句话说，s1 的排列之一是 s2 的 子串 。
示例 1：
输入：s1 = "ab" s2 = "eidbaooo"
输出：true
解释：s2 包含 s1 的排列之一 ("ba").
示例 2：
输入：s1= "ab" s2 = "eidboaoo"
输出：false
提示：
1 <= s1.length, s2.length <= 104s1和s2仅包含小写字母
大小固定的滑动窗口
参考题解：567. 字符串的排列 - 力扣（LeetCode）
public boolean checkInclusion(String s1, String s2)
{
//countS1用于统计s1中各字母的出现次数
int[] countS1 = new int[26];
for (int i = 0; i < s1.length(); i++)
countS1[s1.charAt(i) - 'a']++;
//countS2用于统计滑动窗口（大小固定）中各字母出现次数
int[] countS2 = new int[26];
int left = 0, right = 0;
while (right < s2.length())
{
//窗口移动
countS2[s2.charAt(right) - 'a']++;
right++;
//判断依据：窗口内字母的出现次数等于s1中字母的出现次数
if (Arrays.equals(countS1, countS2))
return true;
//滑动窗口中的元素数量超过限定值的一个
//删去最左侧的元素
if (right - left == s1.length())
{
countS2[s2.charAt(left) - 'a']--;
left++;
}
}
return false;
}
找到字符串中所有字母异位词
438. 找到字符串中所有字母异位词 - 力扣（LeetCode）
给定两个字符串 s 和 p，找到 s 中所有 p 的 异位词 的子串，返回这些子串的起始索引。不考虑答案输出的顺序。
异位词 指由相同字母重排列形成的字符串（包括相同的字符串）。
示例 1:
输入: s = "cbaebabacd", p = "abc"
输出: [0,6]
解释:
起始索引等于 0 的子串是 "cba", 它是 "abc" 的异位词。
起始索引等于 6 的子串是 "bac", 它是 "abc" 的异位词。
示例 2:
输入: s = "abab", p = "ab"
输出: [0,1,2]
解释:
起始索引等于 0 的子串是 "ab", 它是 "ab" 的异位词。
起始索引等于 1 的子串是 "ba", 它是 "ab" 的异位词。
起始索引等于 2 的子串是 "ab", 它是 "ab" 的异位词。
提示:
1 <= s.length, p.length <= 3 * 104s和p仅包含小写字母
用一个list记录索引即可
public List<Integer> findAnagrams(String s, String p)
{
//countS1用于统计p中各字母的出现次数
int[] countS1 = new int[26];
for (int i = 0; i < p.length(); i++)
countS1[p.charAt(i) - 'a']++;
//countS2用于统计滑动窗口（大小固定）中各字母出现次数
int[] countS2 = new int[26];
int left = 0, right = 0;
ArrayList<Integer> ans = new ArrayList<>();
while (right < s.length())
{
//窗口移动
countS2[s.charAt(right) - 'a']++;
right++;
if (Arrays.equals(countS1, countS2))
ans.add(left);
//滑动窗口中的元素数量超过限定值的一个
//删去最左侧的元素
if (right - left == p.length())
{
countS2[s.charAt(left) - 'a']--;
left++;
}
}
return ans;
}