滑动窗口相关算法题总结
文章目录
-
- 前言
- 算法题
-
- 1. LeetCode 1423. 可获得的最大点数
- 2. LeetCode 3 : 无重复字符的最长子串
- 3. LeetCode 1004 : 最大连续1的个数 III
- 4. LeetCode 1438 : 绝对差不超过限制的最长连续子数组
- 5. LeetCode 76 : 最小覆盖子串
- 总结
前言
滑动窗口算法可以将嵌套的循环问题，转换为单循环问题，降低时间复杂度。
算法题
1. LeetCode 1423. 可获得的最大点数
LeetCode 1423
几张卡牌 排成一行，每张卡牌都有一个对应的点数。点数由整数数组 cardPoints 给出。
每次行动，你可以从行的开头或者末尾拿一张卡牌，最终你必须正好拿 k 张卡牌。
你的点数就是你拿到手中的所有卡牌的点数之和。
给你一个整数数组 cardPoints 和整数 k，请你返回可以获得的最大点数。
示例 1：
输入：cardPoints = [1,2,3,4,5,6,1], k = 3
输出：12
解释：第一次行动，不管拿哪张牌，你的点数总是 1 。但是，先拿最右边的卡牌将会最大化你的可获得点数。最优策略是拿右边的三张牌，最终点数为 1 + 6 + 5 = 12 。
示例 2：
输入：cardPoints = [2,2,2], k = 2
输出：4
解释：无论你拿起哪两张卡牌，可获得的点数总是 4 。
示例 3：
输入：cardPoints = [9,7,7,9,7,7,9], k = 7
输出：55
解释：你必须拿起所有卡牌，可以获得的点数为所有卡牌的点数之和。
示例 4：
输入：cardPoints = [1,1000,1], k = 1
输出：1
解释：你无法拿到中间那张卡牌，所以可以获得的最大点数为 1 。
示例 5：
输入：cardPoints = [1,79,80,1,1,1,200,1], k = 3
输出：202
提示：
1 <= cardPoints.length <= 10^5
1 <= cardPoints[i] <= 10^4
1 <= k <= cardPoints.length
/*
* 1
* LeetCode 1423. 可获得的最大点数
* https://leetcode-cn.com/problems/maximum-points-you-can-obtain-from-cards/
*/
int maxScore(vector<int>& cardPoints, int k)
{
// 求两边最大值，就是求中间的最小值，即以求中间的数组连续部分的最小值
int sum = 0;
for(auto num : cardPoints)
{
sum += num;
}
int n = cardPoints.size();
int window = 0;
for(int i = 0; i < n - k; i++)
{
window += cardPoints[i];
}
int minW = window;
for(int i = n-k; i < n; i++)
{
window += cardPoints[i];
window -= cardPoints[i-n+k];
minW = min(minW, window);
}
return sum - minW;
}
2. LeetCode 3 : 无重复字符的最长子串
LeetCode 3
给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。
示例 1:
输入: “abcabcbb”
输出: 3
解释: 因为无重复字符的最长子串是 “abc”，所以其长度为 3。
示例 2:
输入: “bbbbb”
输出: 1
解释: 因为无重复字符的最长子串是 “b”，所以其长度为 1。
示例 3:
输入: “pwwkew”
输出: 3
解释: 因为无重复字符的最长子串是 “wke”，所以其长度为 3。
请注意，你的答案必须是 子串 的长度，“pwke” 是一个子序列，不是子串。
/*
* 2
* LeetCode 3 : 无重复字符的最长子串
* https://leetcode-cn.com/problems/longest-substring-without-repeating-characters/
*/
int lengthOfLongestSubstring(string s)
{
set<char> record;
int res=0,left=0,right=0;
while(right<s.size())
{
if(record.find(s[right])==record.end())
{
record.insert(s[right++]);
res=max(res,(int)record.size());
}
else
{
record.erase(s[left++]);
}
}
return res;
}
3. LeetCode 1004 : 最大连续1的个数 III
LeetCode 1004
给定一个由若干 0 和 1 组成的数组 A，我们最多可以将 K 个值从 0 变成 1 。
返回仅包含 1 的最长（连续）子数组的长度。
示例 1：
输入：A = [1,1,1,0,0,0,1,1,1,1,0], K = 2
输出：6
解释：
[1,1,1,0,0,1,1,1,1,1,1]
粗体数字从 0 翻转到 1，最长的子数组长度为 6。
示例 2：
输入：A = [0,0,1,1,0,0,1,1,1,0,1,1,0,0,0,1,1,1,1], K = 3
输出：10
解释：
[0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1]
粗体数字从 0 翻转到 1，最长的子数组长度为 10。
提示：
1 <= A.length <= 20000
0 <= K <= A.length
A[i] 为 0 或 1
/*
* 3
* LeetCode 1004 : 最大连续1的个数 III
* https://leetcode-cn.com/problems/max-consecutive-ones-iii/
*/
int longestOnes(vector<int>& nums, int k)
{
//使从区间[l , r] 内部0的数量不超过k就行
int l = 0,r = 0, ans = 0, cnt = 0;
while(r < nums.size())
{
if(nums[r] == 0)
cnt++;
if(cnt > k)
{
if(nums[l] == 0)
cnt--;
l++;
}
ans = max(ans, r-l+1);
r++;
}
return ans;
}
4. LeetCode 1438 : 绝对差不超过限制的最长连续子数组
LeetCode 1438
给你一个整数数组 nums ，和一个表示限制的整数 limit，请你返回最长连续子数组的长度，该子数组中的任意两个元素之间的绝对差必须小于或者等于 limit 。
如果不存在满足条件的子数组，则返回 0 。
示例 1：
输入：nums = [8,2,4,7], limit = 4
输出：2
解释：所有子数组如下：
[8] 最大绝对差 |8-8| = 0 <= 4.
[8,2] 最大绝对差 |8-2| = 6 > 4.
[8,2,4] 最大绝对差 |8-2| = 6 > 4.
[8,2,4,7] 最大绝对差 |8-2| = 6 > 4.
[2] 最大绝对差 |2-2| = 0 <= 4.
[2,4] 最大绝对差 |2-4| = 2 <= 4.
[2,4,7] 最大绝对差 |2-7| = 5 > 4.
[4] 最大绝对差 |4-4| = 0 <= 4.
[4,7] 最大绝对差 |4-7| = 3 <= 4.
[7] 最大绝对差 |7-7| = 0 <= 4.
因此，满足题意的最长子数组的长度为 2 。
示例 2：
输入：nums = [10,1,2,4,7,2], limit = 5
输出：4
解释：满足题意的最长子数组是 [2,4,7,2]，其最大绝对差 |2-7| = 5 <= 5 。
示例 3：
输入：nums = [4,2,2,2,4,4,2,2], limit = 0
输出：3
提示：
1 <= nums.length <= 10^5
1 <= nums[i] <= 10^9
0 <= limit <= 10^9
/*
* 4
* LeetCode 1438 : 绝对差不超过限制的最长连续子数组
* https://leetcode-cn.com/problems/longest-continuous-subarray-with-absolute-diff-less-than-or-equal-to-limit/
*/
int longestSubarray(vector<int>& nums, int limit)
{
// multiset能时刻保证序列中的数是有序的，而且序列中可以存在重复的数。
multiset<int> s;
int ans = 0;
int i = 0;
for(int j = 0; j < nums.size(); j++)
{
s.insert(nums[j]);
while(*s.rbegin() - *s.begin() > limit)
{
s.erase(s.find(nums[i]));
i++;
}
ans = max(ans, j - i + 1);
}
return ans;
}
5. LeetCode 76 : 最小覆盖子串
LeetCode 76
给你一个字符串 S、一个字符串 T 。请你设计一种算法，可以在 O(n) 的时间复杂度内，从字符串 S 里面找出：包含 T 所有字符的最小子串。
示例：
输入：S = “ADOBECODEBANC”, T = “ABC”
输出：“BANC”
提示：
如果 S 中不存这样的子串，则返回空字符串 “”。
如果 S 中存在这样的子串，我们保证它是唯一的答案。
/*
* 5
* LeetCode 76 : 最小覆盖子串
* https://leetcode-cn.com/problems/minimum-window-substring/
*/
string minWindow(string s, string t)
{
/*
* 滑动窗口:，首先左右指针指向S的开头，然后右指针右移直到可以包含T，
* 这个时候记录下来子字符串的长度，然后左指针左移，判断当前子字符串是否包含T，
* 直到左指针左移到不包含T为止。然后右指针右移。
*/
unordered_map<char, int> rec;
for(auto c : t)
rec[c] ++;
int len = 0, n = s.size();
int minlen = n;
string res = "";
int l = 0, r = 0;
for( ; r < n; r++)
{
rec[s[r]]--;
if(rec[s[r]] >= 0)
len++;
while(len == t.size())
{
if(r - l + 1 <= minlen)
{
minlen = r - l + 1;
res = s.substr(l, r - l + 1);
}
rec[s[l]] ++;
if(rec[s[l]] > 0)
len--;
l++;
}
}
return res;
}
总结
以上是滑动窗口的相关面试算法题汇总，个别题目也给出了解题思路和注释。所有代码都可以去我的GitHub网站查看，后续也将继续补充其他算法方面的相关题目。虽然网上有很多大佬整理的，包括一些算法书籍如《剑指Offer》等，但还是建议想学习的人，整理自己的框架笔记。