滑动窗口
参考:
//滑动窗口基本框架
//不要记框架,重点是理解滑动窗口的思想
int slidingWindowTemplate(String a, ...) {
// 输入参数有效性判断
if (...) {
...
}
// 申请一个散列,用于记录窗口中具体元素的个数情况
unordered_map<...,...> hash;
// 预处理(可省), 一般情况是改变 hash
...
// left 表示左指针
int left=0;
// result用来存储结果
typename result;
// right 表示右指针
// 移动右指针
for (int right = 0; right < A.length; ++right) {
//根据条件更新hash
if(满足一定条件){
更新hash
}
//这里通常是关键点和难点
//满足一定条件或不满足一定条件更新左指针
while (条件不满足 or 条件满足) {
// 可能会更新结果(可选)
// result=...
...
//移动左指针,更新hash
hash[A[l]]++;
l++;
}
// 可能会更新结果(可选)
// results = ...
}
return results;
}
Leetcode题目
其中424.替换后的最长重复字符
,632.最小区间
,1423.可获得的最大点数
都具有一定的技巧性,难度较大
76.最小覆盖子串
参考代码
class Solution {
public:
string minWindow(string s, string t) {
//定义hash,用于记录当前窗口中包含t中各字符的情况
unordered_map<char,int> hash;
//初始化hash,记录t中各字符的数量
for(auto ch:t)
++hash[ch];
//left为左指针
int left=0;
//result用来存储结果
string result="";
//移动右指针
for(int right=0;right<s.size();++right){
char rch=s[right];
//若rch是t中的字符则更新hash
if(hash.count(rch)){
hash[rch]--;
}
//找到一个子串
while(check(hash)){
//取最小的字符串
string window=s.substr(left,right-left+1);
result=(result.empty()||window.size()<result.size()?window:result);
//移动左指针
char lch=s[left];
if(hash.count(lch)){
hash[lch]++;
}
left++;
}
}
return result;
}
bool check(const unordered_map<char,int> &hash){
for(auto p:hash){
//题目要求找涵盖t的子串,所以这里小于0的子串也是符合条件的
//这里是小于等于0的都满足条件,注意!!!
if(p.second>0) return false;
}
return true;
}
};
567.字符串的排列
参考代码
和上一题类似,只是改变滑动窗口的条件不同.
class Solution {
public:
bool checkInclusion(string s1, string s2) {
//定义hash记录s1中各字符的数量
unordered_map<char,int> hash;
for(auto ch:s1)
++hash[ch];
int left=0;
for(int right=0;right<s2.size();++right){
char rchar=s2[right];
if(hash.count(rchar)){
--hash[rchar];
}
//长度等于s1的长度,此时需要移动左指针
if(right-left+1>=s1.size()){
//判断当前窗口中的子串是否是s1的排列
if(check(hash)) return true;
//移动左指针
char lchar=s2[left];
if(hash.count(lchar)){
++hash[lchar];
}
++left;
}
}
return false;
}
bool check(const unordered_map<char,int> &hash){
for(auto p:hash){
//这题是找排列,所以要全等于0才是满足条件的
if(p.second!=0) return false;
}
return true;
}
};
438.找到字符串中所有字母异位词
参考代码
和上一题一样,没有什么特色。
class Solution {
public:
vector<int> findAnagrams(string s, string p) {
unordered_map<char,int> hash;
for(auto ch:p)
++hash[ch];
int left=0;
vector<int> result;
for(int right=0;right<s.size();++right){
char rchar=s[right];
if(hash.count(rchar)){
--hash[rchar];
}
if(right-left+1>=p.size()){
if(check(hash)) result.push_back(left);
char lchar=s[left];
if(hash.count(lchar)){
++hash[lchar];
}
++left;
}
}
return result;
}
bool check(const unordered_map<char,int> &hash){
for(auto p:hash){
if(p.second!=0) return false;
}
return true;
}
};
3.无重复字符的最长子串
参考代码
class Solution {
public:
int lengthOfLongestSubstring(string s) {
if(s.empty()) return 0;
unordered_map<char,int> hash;
int left=0;
int result=0;
for(int right=0;right<s.size();++right){
char rchar=s[right];
++hash[rchar];
//这里保证滑动窗口中一定是不含有重复字符
//若条件不满足,则移动左指针,直到条件满足
while(!check(hash)){
char lchar=s[left];
--hash[lchar];
++left;
}
//更新结果
result=max(result,(right-left+1));
}
return result;
}
bool check(const unordered_map<char,int> &hash){
for(auto p:hash){
if(p.second>1) return false;
}
return true;
}
};
239.滑动窗口最大值
参考代码
这题的关键是想到用单调非递减的deque
来保存最大值,次大值…
本质上是类单调栈与滑动窗口的结合.
class Solution {
public:
vector<int> maxSlidingWindow(vector<int>& nums, int k) {
//这里借助一个非递增的deque来保存窗口中的最大值,次大值...
deque<int> intDeque;
int left=0,maxValue=INT_MIN;
vector<int> res;
for(int right=0;right<nums.size();++right){
//更新deque,保证dque的非递增性
while((!intDeque.empty())&&(nums[intDeque.back()]<nums[right])){
intDeque.pop_back();
}
intDeque.push_back(right);
//移动左指针
if(right-left+1>=k){
int temp=intDeque.front();
res.push_back(nums[temp]);
//更新deque
if(left==temp){
intDeque.pop_front();
}
left++;
}
}
return res;
}
};
424.替换后的最长重复字符(这题比较难理解…)
参考代码
class Solution {
public:
int characterReplacement(string s, int k) {
//用来记录滑动窗口中字符的情况
vector<int> hash(26,0);
//left表示左指针
int left=0;
//result记录结果
int result=0;
//maxCount并不是当前窗口内出现次数最多字母的次数,而是历史窗口中出现次数最多字母的次数
//这道题的关键!!!
int maxCnt=0;
for(int right=0;right<s.size();++right){
char rch=s[right];
++hash[rch-'A'];
maxCnt=max(maxCnt,hash[rch-'A']);
//始终保证滑动窗口中的子串是满足条件的
//right-left+1-maxCnt即其余需要被替换的字符的数量
//这里很巧妙,非常具有技巧性
if(right-left+1-maxCnt>k){
char lch=s[left];
//这里有个问题需要思考,若maxCnt是left所指的字符,那么这里要不要更新maxCnt的值呢?
//Answer:因为滑动窗口在这里只会扩大或者不变(++left,++right相互抵消)
// 所以即使maxCnt是left所指的字符,maxCnt的值不正确了,依旧不会影响最终的结果
--hash[lch-'A'];
++left;
}
//更新结果
result=max(result,right-left+1);
}
return result;
}
};
632.最小区间
参考代码
本题也极具技巧性…
class Solution {
public:
vector<int> smallestRange(vector<vector<int>>& nums) {
/*
首先将 kk 组数据升序合并成一组,并记录每个数字所属的组,例如:
[[4,10,15,24,26], [0,9,12,20], [5,18,22,30]][[4,10,15,24,26],[0,9,12,20],[5,18,22,30]]
合并升序后得到:
[(0, 1), (4, 0), (5, 2), (9, 1), (10, 0), (12, 1), (15, 0), (18, 2), (20, 1), (22, 2), (24, 0), (26, 0), (30, 2)][(0,1),(4,0),(5,2),(9,1),(10,0),(12,1),(15,0),(18,2),(20,1),(22,2),(24,0),(26,0),(30,2)]
然后只看所属组的话,那么
[1, 0, 2, 1, 0, 1, 0, 2, 1, 2, 0, 0, 2]
只有当滑动窗口中包含所有区间时,才考虑滑动窗口的缩小
[1 0 2] 2 1 0 1 0 2 1 2 0 0 2 [0, 5]
1 [0 2 1] 1 0 1 0 2 1 2 0 0 2 [0, 5]
1 0 [2 1 0] 0 1 0 2 1 2 0 0 2 [0, 5]
1 0 [2 1 0 1] 1 0 2 1 2 0 0 2 [0, 5]
1 0 [2 1 0 1 0] 0 2 1 2 0 0 2 [0, 5]
1 0 2 1 0 [1 0 2] 2 1 2 0 0 2 [0, 5]
1 0 2 1 0 1 [0 2 1] 1 2 0 0 2 [0, 5]
1 0 2 1 0 1 [0 2 1 2] 2 0 0 2 [0, 5]
1 0 2 1 0 1 0 2 [1 2 0] 0 0 2 [20, 24]
1 0 2 1 0 1 0 2 [1 2 0 0] 0 2 [20, 24]
1 0 2 1 0 1 0 2 [1 2 0 0 2] 2 [20, 24]
*/
//初始化
vector<vector<int>> ordered;
for(int i=0;i<nums.size();++i){
for(auto num:nums[i]) ordered.push_back({num,i});
}
sort(ordered.begin(),ordered.end());
//定义hash,记录滑动窗口每一个组中所含的数字个数
unordered_map<int,int> hash;
//res存储最小区间
vector<int> res;
//left表示左指针,k表示区间数量
int left=0,k=0;
for(int right=0;right<ordered.size();++right){
int rid=ordered[right][1];
//判断滑动窗口是否第一次包含该区间
if(hash[rid]==0) ++k;
++hash[rid];
//滑动窗口中包含所有区间后才开始考虑缩小滑动窗口
if(k==nums.size()){
//滑动窗口中包含多个左指针所指的区间中的数
//此时缩小滑动窗口
while(hash[ordered[left][1]]>1){
--hash[ordered[left][1]];
++left;
}
//更新结果
if(res.empty()||ordered[right][0]-ordered[left][0]<res[1]-res[0]){
res=vector({ordered[left][0],ordered[right][0]});
}
}
}
return res;
}
};
1423.可获得的最大点数
参考代码
class Solution {
public:
int maxScore(vector<int>& cardPoints, int k) {
//关键所在:要从两边取到最大值,相当于要找到一个长度为n-k的最小和中间数组
//total_sum记录总的和,cur_sum记录当前滑动窗口中的和
int total_sum=0,cur_sum=0;
for(auto point:cardPoints) total_sum+=point;
//滑动窗口的大小至少为1,否则直接返回总和
if(k==cardPoints.size()) return total_sum;
//滑动窗口的最大大小
int left=0,sz=cardPoints.size()-k;
//result记录可以获得的最大点数,result=toatl_sum-cur_sum
int result=0;
for(int right=0;right<cardPoints.size();++right){
cur_sum+=cardPoints[right];
//保持滑动窗口的大小
if(right-left+1>=sz){
//更新结果
result=max(result,total_sum-cur_sum);
//移动左指针
cur_sum-=cardPoints[left];
++left;
}
}
return result;
}
};