Leetcode 必备算法:聊聊滑动窗口

开发 前端 算法
我们刷leetcode的时候,经常会遇到滑动窗口类型题目。滑动窗口问题非常经典,也很有技巧性,一般大厂也喜欢问。今天跟大家一起来学习滑动窗口的套路,文章如果有不正确的地方,欢迎大家指出哈,感谢感谢~

[[434663]]

前言

我们刷leetcode的时候,经常会遇到滑动窗口类型题目。滑动窗口问题非常经典,也很有技巧性,一般大厂也喜欢问。今天跟大家一起来学习滑动窗口的套路,文章如果有不正确的地方,欢迎大家指出哈,感谢感谢~

  • 什么是滑动窗口?
  • 一道算法题走进滑动窗口
  • 滑动窗口可以用来解决哪些问题?
  • 滑动窗口框架套路
  • leetcode案例分析

什么是滑动窗口

滑动窗口这个词,相信大家耳熟能详啦。因为说到TCP的时候,经常谈起滑动窗口协议(Sliding Window Protocol),它是TCP协议的一种应用,用于网络数据传输时的流量控制,以避免拥塞的发生。

TCP头部有个字段叫win,也即那个16位的窗口大小,它告诉对方本端的TCP接收缓冲区还能容纳多少字节的数据,这样对方就可以控制发送数据的速度,从而达到流量控制的目的。

TCP的滑动窗口在某一个时刻就是固定窗口大小的滑动窗口,随着网络流量等因素改变窗口大小也会随着改变。算法中的滑动窗口有点类似,就是维护一个窗口(队列/数组),不断滑动,然后更新答案。滑动窗口,指的是这样一类问题的求解方法,在数组上通过双指针同向移动而解决的一类问题。

一个例子走进滑动窗口算法

我们来看一道算法题吧:给定一个整数数组,计算长度为k的连续子数组的最大总和。

  1. 输入:arr [] = {100,200,300,400} k = 2 
  2.  
  3. 输出:700 
  4.  
  5. 解释:300 + 400 = 700 

看到这个题目,我们马上想到暴力法去解决了,两个for搞定:

  1. public int maxSum(int[] arry, int k) { 
  2.       int size = arry.length; 
  3.       int maxSum = 0; 
  4.  
  5.       for (int i = 0; i < size - k + 1; i++) { 
  6.           int currentSum = 0; 
  7.           for (int j = 0; j < k; j++) { 
  8.               currentSum = currentSum + arry[i + j]; 
  9.           } 
  10.  
  11.           maxSum = Math.max(currentSum, maxSum); 
  12.       } 
  13.  
  14.       return maxSum; 
  15.   } 

暴力法用了两个嵌套的for循环,时间复杂度不理想,为O(k*n); 而滑动窗口算法可以解决嵌套循环问题,有效降低时间复杂度。

因为滑动窗口就是维护一个窗口,不断滑动,然后更新答案。 我们用滑动窗口算法来走一波:

当k=2时,

  • 我们可以维护一个长度为2的窗口,初始化第一个窗口值的总和,并保存起来
  • 然后窗口不断向右滑动,滑动过程中,与保存的最大值比较,并更新答案。
  • 窗口直到滑到最右边才结束。

当k=3时,类似的

  • 我们可以维护一个长度为3的窗口,初始化第一个窗口值的总和,并保存起来
  • 然后窗口不断向右滑动,滑动过程中,与保存的最大值比较,并更新答案。
  • 窗口直到滑到最右边才结束。

于是,我们就可以写代码啦:

  1. public int maxSum1(int[] arry, int k) { 
  2.      int size = arry.length; 
  3.  
  4.      if (size < k) { 
  5.          return -1; 
  6.      } 
  7.  
  8.      //初始化第一个窗口值的总和 
  9.      int maxSum = 0; 
  10.      for (int i = 0; i < k; i++) { 
  11.          maxSum = maxSum + arry[i]; 
  12.      } 
  13.  
  14.      int sum = maxSum; 
  15.      for (int i = k; i < size; i++) { 
  16.          sum = sum + arry[i] - arry[i - k]; 
  17.          maxSum = Math.max(maxSum,sum); 
  18.      } 
  19.  
  20.      return maxSum; 
  21.  } 

使用了滑动窗口,时间复杂度,只需要O(n)就可以解决啦。

滑动窗口可以解决哪些问题

哪些leetcode的题目,我们可以用滑动窗口去解决呢?

一般情况,子串问题,如什么最小覆盖子串、长度最小的子数组等等,都可以考虑使用滑动窗口算法。比较经典的滑动窗口题目有这些:

  • 无重复字符的最长子串
  • 最小覆盖子串
  • 串联所有单词的子串
  • 至多包含两个不同字符的最长子串
  • 长度最小的子数组
  • 滑动窗口最大值
  • 字符串的排列
  • 最小窗口子序列

都是leetcode的原题,大家可以去leetcode官网找找手感哈。

滑动窗口框架套路

滑动窗口的大致逻辑框架,伪代码如下:

  1. int left =0,right = 0; 
  2. while (right < s.size()){ 
  3.   //增大窗口 
  4.   window.add(s[right]); 
  5.   right++; 
  6.    
  7.   while (window needs shrink){ 
  8.     //缩小窗口 
  9.     window.remove (s[left]); 
  10.     left ++; 
  11.   } 

基本流程就是酱紫:

  • 首先呢,就是获取原字符串的长度。
  • 接着维护一个窗口(数组、哈希、队列)
  • 窗口一步一步向右扩展
  • 窗口在向右扩展滑动过程,需要判断左边是否需要缩减
  • 最后比较更新答案

我们用这个框架,尝试去解一道leetcode的真题吧。

题目:给定一个字符串 s ,请你找出其中不含有重复字符的最长子串的长度。

实例1:

  1. 输入: s = "abcabcbb" 
  2. 输出: 3  
  3. 解释: 因为无重复字符的最长子串是 "abc",所以其长度为 3。 

示例 2:

  1. 输入: s = "bbbbb" 
  2.  
  3. 输出: 1 
  4.  
  5. 解释: 因为无重复字符的最长子串是 "b",所以其长度为 1。 

因为需要判断是否存在重复字符,所以,我们用一个哈希集合(HashSet)来作为窗口

  1. int lengthOfLongestSubstring(String s){ 
  2.      //获取原字符串的长度 
  3.      int len = s.length(); 
  4.      //维护一个哈希集合的窗口 
  5.      Set<Character> windows = new HashSet<>(); 
  6.      int left=0,right =0; 
  7.      int res =0; 
  8.  
  9.      while(right<len){ 
  10.        char c = s.charAt(right); 
  11.        //窗口右移 
  12.        right++; 
  13.  
  14.        //判断是否左边窗口需要缩减,如果已经包含,那就需要缩减 
  15.        while(windows.contains(c)){ 
  16.           windows.remove(s.charAt(left)); 
  17.            left++; 
  18.        } 
  19.        windows.add(c); 
  20.        //比较更新答案 
  21.        res = Math.max(res,windows.size()); 
  22.       } 
  23.      return res; 

leetcode案例分析

我们再来看一道leetcode真题,加深一下印象哈。

题目:给你一个字符串S、一个字符串T。返回S中涵盖T所有字符的最小子串。如果S中不存在涵盖T所有字符的子串,则返回空字符串 "" 。

实例1:

  1. 输入:s = "ADOBECODEBANC", t = "ABC" 
  2.  
  3. 输出:"BANC" 

实例2:

  1. 输入:s = "a", t = "a" 
  2.  
  3. 输出:"a" 

我们还是套用这个框架流程:

  1. - 首先呢,就是获取原字符串的长度。 
  2.  
  3. - 接着维护一个窗口(数组、哈希、队列) 
  4.  
  5. - 窗口一步一步向右扩展 
  6.  
  7. - 窗口在向右扩展滑动过程,需要判断左边是否需要缩减 
  8.  
  9. - 最后比较更新答案 

获取原字符串的长度。

这个比较简单,因为原题还是需要有左右指针去遍历字符串S的。

  1. int len = S.length(); 

接着维护一个窗口(数组、哈希、队列)、右移、左边缩减

我们可以先定义一个最小的窗口,长度为0。定义窗口时,我们得想下:窗口什么时候右移,什么时候左边缩减,怎么比较更新答案。

最小的窗口什么时候可以右移呢?因为题目要求涵盖T的所有子串,所以,窗口一开始就可以右移,直到包含T的所有字母

显然,窗口字符串ADOBEC,是S中涵盖T所有字符的第一个子串。但是呢,我们要找的是最小子串,ADOBEC还不一定是最小的。因为:

  • 1.当前窗口可能包含一个满足题目条件的,更小的子窗口字符串。(可以左边缩减)
  • 2.窗口还没滑到的地方,可能包含一个满足条件的,更小的字符串。(可以窗口继续右移)

找到第一个满足条件的窗口字符串ADOBEC后,为了寻找更小的子窗口字符串。我们可以:

  • 1.左边缩减,如果缩小的窗口仍然满足包含T所有字母,那当前窗口就可能是最小子串。存储下来(就类似于滑动窗口框架的更新答案哈),然后继续从左缩减窗口。
  • 2.如果缩小窗口不能满足包含T的所有字母,这时候就可以停止窗口的左边缩减,转而向右扩大窗口啦。

窗口先左边缩减,再右移动,保存满足条件的窗口

不断重复以上的步骤,把找到满足条件的窗口保存下来,比较得出最小的子串。示例满足条件的最小子串是BANC

这道题的难点,其实是如何判断S的子串包含T,我们一起来看下代码吧:

  1. class Solution { 
  2.     public String minWindow(String s, String t) { 
  3.         if (s.length() == 0 || s.length() < t.length()) { 
  4.             return ""
  5.         } 
  6.  
  7.         int sLen = s.length(); 
  8.         Map<CharacterInteger> lookup = new HashMap<>(); 
  9.           
  10.         for (int i = 0; i < sLen; i++) { 
  11.             lookup.put(s.charAt(i), 0); 
  12.         } 
  13.  
  14.         for (int i = 0; i < t.length(); i++) { 
  15.             Character c = t.charAt(i); 
  16.             if (lookup.containsKey(c)) { 
  17.                 lookup.put(c, lookup.get(c) + 1); 
  18.             } else { 
  19.                 return ""
  20.             } 
  21.         } 
  22.  
  23.         int left = 0; 
  24.         int right = 0; 
  25.         int minLen = Integer.MAX_VALUE; 
  26.         int tCount = t.length(); 
  27.         String result = ""
  28.         while (right < sLen) { 
  29.             char c = s.charAt(right); 
  30.             if (lookup.get(c) > 0) tCount--; 
  31.             lookup.put(c, lookup.get(c) - 1); 
  32.             //窗口右移 
  33.             right++; 
  34.              
  35.             //已经包含T的所有字母 
  36.             while (tCount == 0) { 
  37.                 //比较更新答案 
  38.                 if (minLen > right - left) { 
  39.                     minLen = right - left
  40.                     result = s.substring(leftright); 
  41.                 } 
  42.                 char c2 = s.charAt(left); 
  43.                 if (lookup.get(c2) == 0) tCount++; 
  44.                 lookup.put(c2, lookup.get(c2) + 1); 
  45.                 //窗口从左边缩减 
  46.                 left++; 
  47.             } 
  48.         } 
  49.         return result; 
  50.     } 

leetcode提交结果如下:

 

责任编辑:武晓燕 来源: 捡田螺的小男孩
相关推荐

2023-05-15 07:32:01

算法训练滑动窗口

2021-10-14 08:19:50

双指针滑动窗口算法

2022-04-02 10:23:12

MySQL数据库

2023-08-11 07:44:40

TCP滑动窗口数据

2021-01-04 10:39:27

滑动问题滑动窗口Python

2023-08-26 20:56:02

滑动窗口协议

2022-02-04 21:56:59

回溯算法面试

2021-09-30 09:58:14

路径总和二叉树

2022-02-18 08:26:12

TopK数组面试题

2022-06-17 07:49:14

缓存LRU

2015-01-15 09:21:24

TCP窗口

2023-10-09 07:11:03

排序算法序列

2023-11-28 09:19:12

2022-06-28 15:13:12

Vuediff 算法

2023-05-30 07:58:01

谷歌搜索算法

2020-02-19 19:18:02

缓存查询速度淘汰算法

2023-11-15 07:40:40

2013-11-18 10:04:31

TCP 滑动窗口

2024-09-13 09:11:57

2020-05-27 10:10:56

对称加密Hash算法数字签名
点赞
收藏

51CTO技术栈公众号