首先给出算法的框架模板：
/* 滑动窗⼝算法框架 */
void slidingWindow(string s, string t) {
unordered_map<char, int> need, window;
for (char c : t)
need[c]++;
int left = 0, right = 0;
int valid = 0;
while (right < s.size()) {
// c 是将移⼊窗⼝的字符
char c = s[right];
// 右移窗⼝
right++;
// 进⾏窗⼝内数据的⼀系列更新
待填写代码处...
// 判断左侧窗⼝是否要收缩
while (valid == need.size()) {
// d 是将移出窗⼝的字符
char d = s[left];
// 左移窗⼝
left++;
// 进⾏窗⼝内数据的⼀系列更新
待填写代码处...
}
}
}
例题实践：
1、leetcode 编号76. 最小覆盖子串
题意：
给你一个字符串 S、一个字符串 T，请在字符串 S 里面找出：包含 T 所有字符的最小子串。
示例：
输入: S = “ADOBECODEBANC”, T = “ABC”
输出: “BANC”
说明：
如果 S 中不存这样的子串，则返回空字符串 “”。
如果 S 中存在这样的子串，我们保证它是唯一的答案。
解题思路：
1、我们在字符串 S 中使⽤双指针中的左右指针技巧，初始化 left = 0,right = 0 ，把索引左闭右开区间 [left, right) 称为⼀个「窗⼝」。
2、我们先不断地增加 right 指针扩⼤窗⼝ [left, right) ，直到窗⼝中的字符串符合要求（包含了 T 中的所有字符）。
3、此时，我们停⽌增加 right ，转⽽不断增加 left 指针缩⼩窗⼝[left, right) ，直到窗⼝中的字符串不再符合要求（不包含 T 中的所有字符了）。同时，每次增加 left ，我们都要更新⼀轮结果。
4、重复第 2 和第 3 步，直到 right 到达字符串 S 的尽头。这个思路其实也不难，第 2 步相当于在寻找⼀个「可⾏解」，然后第 3 步在优化这个「可⾏解」，最终找到最优解，也就是最短的覆盖⼦串。
Ac代码：
string minWindow(string s, string t) {
unordered_map<int,int> need,window;
for(int i = 0; i < t.size(); i++)
need[t[i]]++;
int left = 0, right = 0;
int start = 0, end = INT_MAX;
int valid = 0;
while(right < s.size()) {
char c = s[right];
right++;
//进行窗口的一系列更新
if(need.count(c)) {
window[c]++;
if(need[c] == window[c]) {
valid++;
}
}
while(valid == need.size()) {
if(right-left < end) {
start = left;
end = right-left;
}
char d = s[left];
left++;
if(need.count(d)) {
window[d]--;
if(need[d] > window[d]) {
valid--;
}
}
}
}
return end == INT_MAX ? "" : s.substr(start,end);
}
2、LeetCode 编号567. 字符串的排列
题意：
给定两个字符串 s1 和 s2，写一个函数来判断 s2 是否包含 s1 的排列。
换句话说，第一个字符串的排列之一是第二个字符串的子串。
示例1:
输入: s1 = “ab” s2 = “eidbaooo”
输出: True
解释: s2 包含 s1 的排列之一 (“ba”).
示例2:
输入: s1= “ab” s2 = “eidboaoo”
输出: False
AC代码：
bool checkInclusion(string s1, string s2) {
unordered_map<int,int> need,window;
for(auto c : s1) {
need[c]++;
}
int left = 0, right = 0;
int valid = 0;
while(right < s2.size()) {
char c = s2[right];
right++;
if(need.count(c)) {
window[c]++;
if(need[c] == window[c])
valid++;
}
while(right-left >= s1.size()) {
if(valid == need.size())
return true;
char d = s2[left];
left++;
if(need.count(d)) {
if(window[d] == need[d])
valid--;
window[d]--;
}
}
}
return false;
}
3、LeetCode 编号438. 找到字符串中所有字母异位词
题意：
给定一个字符串 s 和一个非空字符串 p，找到 s 中所有是 p 的字母异位词的子串，返回这些子串的起始索引。
字符串只包含小写英文字母，并且字符串 s 和 p 的长度都不超过 20100。
说明：
字母异位词指字母相同，但排列不同的字符串。
不考虑答案输出的顺序。
示例 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" 的字母异位词。
AC代码：
vector<int> findAnagrams(string s, string p) {
unordered_map<int,int> need,window;
for(auto c : p) {
need[c]++;
}
vector<int> res;
int left = 0, right = 0;
int valid = 0;
while(right < s.size()) {
char c = s[right];
right++;
if(need.count(c)) {
window[c]++;
if(need[c] == window[c])
valid++;
}
while(right-left >= p.size()) {
if(valid == need.size())
res.push_back(left);
char d = s[left];
left++;
if(need.count(d)){
if(window[d] == need[d])
valid--;
window[d]--;
}
}
}
return res;
}
4、LeetCode 编号3. 无重复字符的最长子串
题意：
给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。
示例 1:
输入: "abcabcbb"
输出: 3
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
示例 2:
输入: "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
示例 3:
输入: "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
请注意，你的答案必须是 子串 的长度，“pwke” 是一个子序列，不是子串。
AC代码：
int lengthOfLongestSubstring(string s) {
unordered_map<int,int> window;
int left = 0, right = 0;
int res = 0;
while(right < s.size()) {
char c = s[right];
right++;
window[c]++;
while(window[c] > 1) {
char d = s[left];
left++;
window[d]--;
}
res = max(res,right-left);
}
return res;
}
后面有时间详细说明……