滑动窗口
1.题目特点
适用场景：求解字符串满足条件的子串
2. 算法模板
public void slidWindow(String s, String t) {
// 1.构造need map
Map<Character, Integer> need = new HashMap<>();
for (int i = 0; i < t.length(); i++) {
char c = t.charAt(i);
need.put(c, need.getOrDefault(c, 0) + 1);
}
// 2.滑动窗口
Map<Character, Integer> window = new HashMap<>(); // 目标window
int left = 0, right = 0;
int valid = 0;
while (right < s.length()) {
char d = s.charAt(right); // d是将移入窗口的字符
right++; // 右移窗口
... // 进行更新窗口内数据的一系列操作
while (window need shrink) {
char e = s.charAt(left); // e是将移除窗口的字符
left++; // 左移窗口
... // 进行更新窗口内数据的一系列操作
}
}
}
遇到具体题目时我们应该思考如下四点：
- 移动right扩大窗口时，即加入字符时，应该更新哪些数据？
- 什么条件下，我们开始缩小窗口？
- 移动left缩小窗口时，应该更新哪些数据？
- 题目求的结果是在扩大窗口还是缩小窗口时进行更新？
3.典型题目
给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串，则返回空字符串 "" 。
注意：
对于 t 中重复字符，我们寻找的子字符串中该字符数量必须不少于 t 中该字符数量。
如果 s 中存在这样的子串，我们保证它是唯一的答案。示例 1：
输入：s = "ADOBECODEBANC", t = "ABC"
输出："BANC"
示例 2：输入：s = "a", t = "a"
输出："a"
示例 3:输入: s = "a", t = "aa"
输出: ""
解释: t 中两个字符 'a' 均应包含在 s 的子串中，
因此没有符合条件的子字符串，返回空字符串。提示：
1 <= s.length, t.length <= 105
s 和 t由英文字母组成
class Solution {
public String minWindow(String s, String t) {
//解题思路：滑动窗口
Map<Character, Integer> need = new HashMap<>(); // 由于t中可能存在重复字符，所以这里用HashMap来存储
Map<Character, Integer> window = new HashMap<>();
int left = 0, right = 0;
int valid = 0;
int len = Integer.MAX_VALUE;
int start = 0;
// 1.遍历t构造need map
for (int i = 0; i < t.length(); i++) {
char c = t.charAt(i); // 右边界将要被移入窗口的元素
need.put(c, need.getOrDefault(c, 0) + 1);
}
// 2.滑动窗口
while (right < s.length()) {
char d = s.charAt(right);
right++;
if (need.containsKey(d)) {
window.put(d, window.getOrDefault(d, 0) + 1); // 更新窗口中的数据
if (window.get(d).equals(need.get(d))) {
valid++;
}
}
while (valid == need.size()) { // 当窗口包含t的全部字符时缩小窗口
if (right - left < len) { // 更新结果值
start = left;
len = right - left;
}
char e = s.charAt(left); // 左边界将要被移出窗口的元素
left++;
if (need.containsKey(e)) { // 更新窗口数据
if (window.get(e).equals(need.get(e))) {
valid--;
}
window.put(e, window.get(e) - 1);
}
}
}
return len == Integer.MAX_VALUE ? "" : s.substring(start, start + len);
}
}
给你两个字符串 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 <= 104
s1 和 s2 仅包含小写字母
class Solution {
public boolean checkInclusion(String s1, String s2) {
if (s1.length() > s2.length()) return false;
Map<Character, Integer> need = new HashMap<>();
for (int i = 0; i < s1.length(); i++) {
char c = s1.charAt(i);
need.put(c, need.getOrDefault(c, 0) + 1);
}
Map<Character, Integer> window = new HashMap<>();
int left = 0, right = 0;
int valid = 0;
while (right < s2.length()) {
char d = s2.charAt(right);
right++;
if (need.containsKey(d)) { // 更新窗口数据
window.put(d, window.getOrDefault(d, 0) + 1);
if (window.get(d).equals(need.get(d))) {
valid++;
}
}
while (right - left == s1.length()) { // 当right - left等于s1的长度是缩小窗口
if (valid == need.size()) { // 当s1中的字符全部都有时返回结果
return true;
}
char e = s2.charAt(left);
left++;
if (need.containsKey(e)) {
if (window.get(e).equals(need.get(e))) {
valid--;
}
window.put(e, window.getOrDefault(e, 0) - 1);
}
}
}
return false;
}
}
给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。
示例 1:
输入: s = "abcabcbb"
输出: 3
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
示例 2:输入: s = "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
示例 3:输入: s = "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。提示：
0 <= s.length <= 5 * 104
s 由英文字母、数字、符号和空格组成
class Solution {
public int lengthOfLongestSubstring(String s) {
if (s.length() == 0) return 0;
Map<Character, Integer> window = new HashMap<>();
int left = 0, right = 0;
int res = 0;
while (right < s.length()) {
char c = s.charAt(right);
right++;
window.put(c, window.getOrDefault(c, 0) + 1); // 更新窗口数据,将读到的右侧数据更新到map中
while (window.get(c) > 1) { // 窗口中有重复数据则收缩窗口
char d = s.charAt(left);
left++;
window.put(d, window.get(d) - 1); // 更新窗口数据
}
res = Math.max(res, right - left);
}
return res;
}
}
给定两个字符串 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 * 104
s 和 p 仅包含小写字母
class Solution {
public List<Integer> findAnagrams(String s, String p) {
if (p.length() > s.length()) return new ArrayList();
Map<Character, Integer> need = new HashMap<>();
for (int i = 0; i < p.length(); i++) {
char c = p.charAt(i);
need.put(c, need.getOrDefault(c, 0) + 1);
}
Map<Character, Integer> window = new HashMap<>();
int left = 0, right = 0;
int valid = 0;
List<Integer> res = new ArrayList<>();
while (right < s.length()) {
char d = s.charAt(right);
right++;
if (need.containsKey(d)) { // 更新窗口数据
window.put(d, window.getOrDefault(d, 0) + 1);
if (window.get(d).equals(need.get(d))) {
valid++;
}
}
while (right - left >= p.length()) { // 当窗口长度大于等于p的长度时
if (valid == need.size()) {
res.add(left);
}
char e = s.charAt(left);
left++;
if (need.containsKey(e)) {
if (window.get(e).equals(need.get(e))) {
valid--;
}
window.put(e, window.getOrDefault(e, 0) - 1);
}
}
}
return res;
}
}
给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。
返回 滑动窗口中的最大值 。
示例 1：
输入：nums = [1,3,-1,-3,5,3,6,7], k = 3
输出：[3,3,5,5,6,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
示例 2：输入：nums = [1], k = 1
输出：[1]提示：
1 <= nums.length <= 105
-104 <= nums[i] <= 104
1 <= k <= nums.length
class Solution {
public int[] maxSlidingWindow(int[] nums, int k) {
// 解法一：问题的难点是如何求出每个窗口中的最大值
// 解决思路：维护一个单调递减队列，每次移动窗口判断单调队列的队头元素是否还在窗口中，如果不在窗口中就将其移出队列，
// 从单调队列中获取队头元素的时间复杂度是O(1)
if (nums.length == k) return new int[]{Arrays.stream(nums).max().getAsInt()};
Deque<Integer> queue = new LinkedList<>();
int[] res = new int[nums.length - k + 1];
// 构建第一个窗口
for (int i = 0; i < k; i++) {
while (!queue.isEmpty() && nums[i] >= nums[queue.peekLast()]) {
queue.pollLast();
}
queue.offerLast(i);
}
res[0] = nums[queue.peekFirst()];
// 向右移动窗口
for (int i = k; i < nums.length; i++ ) { // 更新单调队列，每当有比队尾大的元素，则循环删除队尾元素，直到队尾大于等于新元素
while (!queue.isEmpty() && nums[i] >= nums[queue.peekLast()]) {
queue.pollLast();
}
queue.offerLast(i);
if (i - k == queue.peekFirst()) { // 这时候判断窗口左侧移除的元素如果是队头，则更新单调队列
queue.pollFirst();
}
// 更新res
res[i - k + 1] = nums[queue.peekFirst()];
}
return res; // 我们这里单调队列里存储的是更大元素的小标而不是值，是为了方便窗口移动时跟移出的元素做比较
}
}
规律：
- 窗口收缩的条件：窗口内的字符串满足target字符串、窗口内元素个数大于等于target字符串个数、窗口内有重复元素
