转自 https://www.zhihu.com/question/314669016
概念
滑动窗口算法可以用以解决数组/字符串的子元素问题,它可以将嵌套的循环问题,转换为单循环问题,降低时间复杂度。
示例1
给定一个整数数组,计算长度为 'k' 的连续子数组的最大总和。
输入:arr [] = {100,200,300,400}
k = 2
输出:700
解释:300 + 400 = 700
暴力法
我们可以很容易想到暴力法来解决这个问题,使用两个 for 循环来不断查找长度为 k 的最大总和。
JavaScript 示例代码
function maxSum(arr, k) {
const n = arr.length
let maxSum = Number.MIN_SAFE_INTEGER;
for (let i = 0; i < n - k + 1; i++) {
let currentSum = 0;
for (let j = 0; j < k; j++) {
currentSum = currentSum + arr[i + j];
}
maxSum = Math.max(currentSum, maxSum);
}
return maxSum;
}
因为包含两个 for 循环,它的时间复杂度是 O(k * n)。
滑动窗口算法
滑动窗口算法可以将嵌套的循环问题,转换为单循环问题,降低时间复杂度。
根据示例,当 k 等于 2 时,我们维护一个长度为 2 的窗口。
- 窗口内的值的和保存在一个变量中;
- 通过不断的往右滑动来算出当前窗口的值,并与保存的最大值作比较;
- 当窗口滑动到最右边时终止滑动;
滑动窗口
JavaScript 示例代码
function maxSum(arr, k) {
const n = arr.length;
if (n < k) {
return -1;
}
// 计算出第一个窗口的值
let maxSum = 0;
for (let i = 0; i < k; i++) {
maxSum += arr[i];
}
let sum = maxSum;
for (let i = k; i < n; i++) {
// 新窗口的和 = 前一个窗口的和 + 新进入窗口的值 - 移出窗口的值
sum += arr[i] - arr[i - k];
maxSum = Math.max(maxSum, sum);
}
return maxSum;
}
我们在一个循环中计算出了长度为 'k' 的子数组的最大总和,它的时间复杂度是 O(n)。我们可以使用滑动窗口算法解决 查找最大/最小k子阵列,XOR,乘积,求和等问题。
示例2
给定一个字符串 S 和一个字符串 T,请在 S 中找出包含 T 所有字母的最小子串。(minimum-window-substring)
输入: S = "ADOBECODEBANC", T = "ABC"
输出: "BANC"
这个问题让我们无法按照示例 1 中的方法进行查找,因为它不是给定了窗口大小让你找对应的值,而是给定了对应的值,让你找最小的窗口。
我们仍然可以使用滑动窗口算法,只不过需要换一个思路。
既然是找最小的窗口,我们先定义一个最小的窗口,也就是长度为 0 的窗口。
长度为 0 的窗口
我们比较一下当前窗口在的位置的字母,是否是 T 中的一个字母。
很明显, A 是 ABC 中的一个字母,也就是 T 所有字母的最小子串 可能包含当前位置的 S 的值。
如果包含,我们开始扩大窗口,直到扩大后的窗口能够包含 T 所有字母。
AD 不能够包含 T 所有字母
ADOBEC 包含 T 的所有字母
假设题目是 在 S 中找出包含 T 所有字母的第一个子串,我们就已经解决问题了,但是题目是找到最小的子串,就会存在一些问题。
- 当前窗口内可能包含了一个更小的能满足题目的窗口
- 窗口没有滑动到的位置有可能包含了一个更小的能满足题目的窗口
为了解决可能出现的问题,当我们找到第一个满足的窗口后,就从左开始缩小窗口。
- 如果缩小后的窗口仍满足包含 T 所有字母的要求,则当前窗口可能是最小能满足题目的窗口,储存下来之后,继续从左开始缩小窗口。
- 如果缩小后的窗口不能满足包含 T 所有字母的要求,则缩小窗口停止,从右边开始扩大窗口。
DOBEC 不包含 T 的所有字母
DOBECODEBA 包含 T 的所有字母
不断重复上面的步骤,直到窗口滑动到最右边,且找不到合适的窗口为止。最小满足的窗口就是我们要找的 S 中包含 T 所有字母的最小子串。
BANC 包含 T 的所有字母,且是最小子串
JavaScript 示例代码
/**
* @param {string} s
* @param {string} t
* @return {string}
*/
var minWindow = function(s, t) {
const map = {};
for (let i = 0; i < t.length; i++) {
if (map[t[i]]) {
map[t[i]]++;
} else {
map[t[i]] = 1;
}
}
let left = 0;
let right = 0;
let count = t.length;
let max = Number.MAX_SAFE_INTEGER;
let res = s;
while (right < s.length) {
if (map[s[right]] > 0) {
count--;
}
map[s[right]]--;
right++;
while (count === 0) {
if (right - left < max) {
max = right - left;
res = s.slice(left, right);
}
map[s[left]]++;
if (map[s[left]] > 0) {
count++;
}
left++;
}
}
return max === Number.MAX_SAFE_INTEGER ? "" : res;
};
它的时间复杂度是 O(s + t)
示例3
给定一个字符串,请你找出其中不含有重复字符的 最长子串 的长度。(longest-substring-without-repeating-characters)
输入: "abcabcbb"
输出: 3
解释: 因为无重复字符的最长子串是 "abc",所以其长度为 3。
和示例 2 相似,我们不断的扩大/缩小窗口,把无重复字母的窗口大小保存下来,直到窗口滑动结束,就找到了不含有重复字符的 最长子串 的长度。
JavaScript 示例代码
/**
* @param {string} s
* @return {number}
*/
var lengthOfLongestSubstring = function(s) {
const map = {};
let left = 0;
let right = 0;
let max = 0;
while (right < s.length) {
if (!map[s[right]]) {
map[s[right]] = 1;
right++;
} else {
while (left < right) {
delete map[s[left]];
if (map[s[left++]] === map[s[right]]) {
break;
}
}
}
max = Math.max(max, right - left);
}
return max;
};
时间复杂度是 O(n)
示例4
给定一个字符串 s 和一个非空字符串 p,找到 s 中所有是 p 的字母异位词的子串,返回这些子串的起始索引。(find-all-anagrams-in-a-string)
输入:
s: "cbaebabacd" p: "abc"
输出:
[0, 6]
解释:
起始索引等于 0 的子串是 "cba", 它是 "abc" 的字母异位词。
起始索引等于 6 的子串是 "bac", 它是 "abc" 的字母异位词。
与示例 1 类似,我们维护一个长度为 p 的窗口,然后不断往右滑动查找当前窗口是否为 p 的字母异位词。
var findAnagrams = function(s, p) {
const map = new Array(26).fill(0);
for (let i = 0; i < p.length; i++) {
map[p[i].charCodeAt() - 97]++;
}
const r = [];
for (let i = 0, j = 0; i < s.length; i++) {
const c = s[i].charCodeAt() - 97;
map[c]--;
while (map[c] < 0) {
const c2 = s[j].charCodeAt() - 97;
j++;
map[c2]++;
}
if (i - j + 1 === p.length) {
r.push(j);
}
}
return r;
};
时间复杂度为 O(s + p)
滑动窗口算法的应用
TCP 流量控制
参考:
Window Sliding Technique - GeeksforGeeks
https://www.youtube.com/watch?v=eS6PZLjoaq8&t=548s
公众号:五分钟学算法
46 人赞同了该回答
前言科普:什么是滑动窗口算法
滑动问题包含一个滑动窗口,它是一个运行在一个大数组上的子列表,该数组是一个底层元素集合。
假设有数组 [a b c d e f g h ],一个大小为 3 的 滑动窗口 在其上滑动,则有:
[a b c]
[b c d]
[c d e]
[d e f]
[e f g]
[f g h]
一般情况下就是使用这个窗口在数组的 合法区间 内进行滑动,同时 动态地 记录一些有用的数据,很多情况下,能够极大地提高算法地效率。
1. 滑动窗口最大值
题目来源于 LeetCode 上第 239 号问题:滑动窗口最大值。题目难度为 Hard,目前通过率为 40.5% 。
题目描述
给定一个数组 nums,有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口 k 内的数字。滑动窗口每次只向右移动一位。
返回滑动窗口最大值。
示例:
输入: 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
题目解析
利用一个 双端队列,在队列中存储元素在数组中的位置, 并且维持队列的严格递减,,也就说维持队首元素是 最大的 ,当遍历到一个新元素时, 如果队列里有比当前元素小的,就将其移除队列,以保证队列的递减。当队列元素位置之差大于 k,就将队首元素移除。
补充:什么是双端队列(Dqueue)
Deque 的含义是 “double ended queue”,即双端队列,它具有队列和栈的性质的数据结构。顾名思义,它是一种前端与后端都支持插入和删除操作的队列。
Deque 继承自 Queue(队列),它的直接实现有 ArrayDeque、LinkedList 等。
动画描述
代码实现
class Solution {
public int[] maxSlidingWindow(int[] nums, int k) {
//有点坑,题目里都说了数组不为空,且 k > 0。但是看了一下,测试用例里面还是有nums = [], k = 0,所以只好加上这个判断
if (nums == null || nums.length < k || k == 0) return new int[0];
int[] res = new int[nums.length - k + 1];
//双端队列
Deque<Integer> deque = new LinkedList<>();
for (int i = 0; i < nums.length; i++) {
//在尾部添加元素,并保证左边元素都比尾部大
while (!deque.isEmpty() && nums[deque.getLast()] < nums[i]) {
deque.removeLast();
}
deque.addLast(i);
//在头部移除元素
if (deque.getFirst() == i - k) {
deque.removeFirst();
}
//输出结果
if (i >= k - 1) {
res[i - k + 1] = nums[deque.getFirst()];
}
}
return res;
}
}
2. 无重复字符的最长子串
题目来源于 LeetCode 上第 3 号问题:无重复字符的最长子串。题目难度为 Medium,目前通过率为 29.0% 。
题目描述
给定一个字符串,请你找出其中不含有重复字符的 最长子串 的长度。
示例 1:
输入: "abcabcbb"
输出: 3
解释: 因为无重复字符的最长子串是 "abc",所以其长度为 3。
题目解析
建立一个256位大小的整型数组 freg ,用来建立字符和其出现位置之间的映射。
维护一个滑动窗口,窗口内的都是没有重复的字符,去尽可能的扩大窗口的大小,窗口不停的向右滑动。
- (1)如果当前遍历到的字符从未出现过,那么直接扩大右边界;
- (2)如果当前遍历到的字符出现过,则缩小窗口(左边索引向右移动),然后继续观察当前遍历到的字符;
- (3)重复(1)(2),直到左边索引无法再移动;
- (4)维护一个结果res,每次用出现过的窗口大小来更新结果 res,最后返回 res 获取结果。
动画描述
代码实现
// 滑动窗口
// 时间复杂度: O(len(s))
// 空间复杂度: O(len(charset))
class Solution {
public:
int lengthOfLongestSubstring(string s) {
int freq[256] = {0};
int l = 0, r = -1; //滑动窗口为s[l...r]
int res = 0;
// 整个循环从 l == 0; r == -1 这个空窗口开始
// 到l == s.size(); r == s.size()-1 这个空窗口截止
// 在每次循环里逐渐改变窗口, 维护freq, 并记录当前窗口中是否找到了一个新的最优值
while(l < s.size()){
if(r + 1 < s.size() && freq[s[r+1]] == 0){
r++;
freq[s[r]]++;
}else { //r已经到头 || freq[s[r+1]] == 1
freq[s[l]]--;
l++;
}
res = max(res, r-l+1);
}
return res;
}
};
3. 存在重复元素 II
题目来源于 LeetCode 上第 219 号问题:存在重复元素 II。题目难度为 Easy,目前通过率为 33.9% 。
题目描述
给定一个整数数组和一个整数 k,判断数组中是否存在两个不同的索引 i 和 j,使得 nums [i] = nums [j],并且 i 和 j 的差的绝对值最大为 k。
题目解析
使用用滑动窗口与查找表来解决。
- 设置查找表
record
,用来保存每次遍历时插入的元素,record
的最大长度为k
- 遍历数组
nums
,每次遍历的时候在record
查找是否存在相同的元素,如果存在则返回true
,遍历结束 - 如果此次遍历在
record
未查找到,则将该元素插入到record
中,而后查看record
的长度是否为k + 1
- 如果此时
record
的长度是否为k + 1
,则删减record
的元素,该元素的值为nums[i - k]
- 如果遍历完整个数组
nums
未查找到则返回false
动画描述
代码实现
// 时间复杂度: O(n)
// 空间复杂度: O(k)
class Solution {
public:
bool containsNearbyDuplicate(vector<int>& nums, int k) {
if(nums.size() <= 1) return false;
if(k <= 0) return false;
unordered_set<int> record;
for(int i = 0 ; i < nums.size() ; i ++){
if(record.find(nums[i]) != record.end()){
return true;
}
record.insert(nums[i]);
// 保持record中最多有k个元素
// 因为在下一次循环中会添加一个新元素,使得总共考虑k+1个元素
if(record.size() == k + 1){
record.erase(nums[i - k]);
}
}
return false;
}
};
4. 长度最小的子数组
题目来源于 LeetCode 上第 209 号问题:长度最小的子数组。题目难度为 Medium,目前通过率为 37.7% 。
题目描述
给定一个含有 n 个正整数的数组和一个正整数 s ,找出该数组中满足其和 ≥ s 的长度最小的连续子数组。如果不存在符合条件的连续子数组,返回 0。
示例:
输入: s = 7, nums = [2,3,1,2,4,3]
输出: 2
解释: 子数组 [4,3] 是该条件下的长度最小的连续子数组。
// 滑动窗口的思路
// 时间复杂度: O(n)
// 空间复杂度: O(1)
class Solution {
public int minSubArrayLen(int s, int[] nums) {
int l= 0,r = -1; // nums[l...r]为我们的滑动窗口
int sum = 0;
int result = nums.length + 1;
while (l < nums.length){ // 窗口的左边界在数组范围内,则循环继续
if( r+1 <nums.length && sum < s){
r++;
sum += nums[r];
}else { // r已经到头 或者 sum >= s
sum -= nums[l];
l++;
}
if(sum >= s){
result = (r-l+1) < result ? (r-l+1) : result ;
}
}
if(result==nums.length+1){
return 0;
}
return result;
}
}
4. 长度最小的子数组
题目来源于 LeetCode 上第 209 号问题:长度最小的子数组。题目难度为 Medium,目前通过率为 37.7% 。
题目描述
给定一个含有 n 个正整数的数组和一个正整数 s ,找出该数组中满足其和 ≥ s 的长度最小的连续子数组。如果不存在符合条件的连续子数组,返回 0。
示例:
输入: s = 7, nums = [2,3,1,2,4,3]
输出: 2
解释: 子数组 [4,3] 是该条件下的长度最小的连续子数组。
题目解析
定义两个指针 left 和 right ,分别记录子数组的左右的边界位置。
- (1)让 right 向右移,直到子数组和大于等于给定值或者 right 达到数组末尾;
- (2)更新最短距离,将 left 像右移一位, sum 减去移去的值;
- (3)重复(1)(2)步骤,直到 right 到达末尾,且 left 到达临界位置
动画描述
设置滑动窗口的长度为 0 ,位于数轴的最左端。
1 .滑动窗口右端 R 开始移动,直到区间满足给定的条件,也就是和大于 7 ,此时停止于第三个元素 2,当前的最优长度为 4
2. 滑动窗口左端 L 开始移动,缩小滑动窗口的大小,停止于第一个元素 3,此时区间和为 6,使得区间和不满足给定的条件(此时不大于 7)
3. 滑动窗口右端 R 继续移动,停止于第四个元素 4,此时和位 10 ,但最优长度仍然为 4
代码实现
// 滑动窗口的思路
// 时间复杂度: O(n)
// 空间复杂度: O(1)
class Solution {
public int minSubArrayLen(int s, int[] nums) {
int l= 0,r = -1; // nums[l...r]为我们的滑动窗口
int sum = 0;
int result = nums.length + 1;
while (l < nums.length){ // 窗口的左边界在数组范围内,则循环继续
if( r+1 <nums.length && sum < s){
r++;
sum += nums[r];
}else { // r已经到头 或者 sum >= s
sum -= nums[l];
l++;
}
if(sum >= s){
result = (r-l+1) < result ? (r-l+1) : result ;
}
}
if(result==nums.length+1){
return 0;
}
return result;
}
}