滑动窗口总结模板与例题（c++）

已于 2022-12-27 21:11:16 修改
阅读量2.7k 收藏 21
点赞数 5
分类专栏： leetcode与算法 文章标签： 哈希算法 数据结构 散列表
于 2022-11-21 23:46:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jj6666djdbbd/article/details/127966940
版权

文章目录

本篇主要总结关于滑动窗口的相关做题技巧与注意事项，有关滑动窗口是什么请参阅其他文章，本篇主要用于在了解滑动窗口的构造后，快速掌握滑动窗口的做题技巧与做题模板，便于以后复习参阅。

滑动窗口模板

  1. 定义变量：确定需要维护的变量：数之和，最大最小长度，哈希表等
  2. 滑动窗口：确定滑动窗口的左右边界，开始滑动窗口
  3. 合法更新：在滑动窗口有效的情况下，合法的更新需要维护的变量
  4. 非法更新（二次更新）：在滑动窗口无效或者即将无效的情况下，更新维护的变量，并且收缩滑动窗口的左边界，非法更新的两种情况：
  • 滑动窗口的长度是固定的！！！ 使用 if条件来更新
  • 滑动窗口的长度是可变的！！！ 使用 while条件来更新
  1. 返回与得到答案
int func(vector<int>& nums,int k)
{
	//Step1. 定义维护变量：
	1. unordered_map<char,int> m;	//在需要统计字符或者数字出现的次数的时候，使用哈希表
	2. int sum=0,res=0;			//在需要记录整数数组中的子序列和或者其他求和时，使用sum记录每一次滑动窗口的子和，再利用res得到最大的或者最小的结果	
	3. int len=0,start=0;		//得到字符串的字串，len记录字串长度，start标识字串开始位置

	//Step2. 确定滑动窗口的边界，开始滑动：
	int left=0,right=0;
	while (right< n) 	// n: 数组长度	
	{
		//Step3. 合法更新：每进行一次滑动时，必须要更新的变量：如Step1的哈希表，sum,res,len与start等等
		......
		if (满足条件) //满足某一种条件：例如滑动窗口的长度：right-left+1 与某个值相等时，则进行一次判断，保存临时结果
		{
			//更新：res=max(res,sum)  ......
		}
		//Step4: 非法更新
		//(1): 滑动窗口的长度固定：使用if来更新窗口
		while (right-left+1 > m.size())//举个例子：无重复字符的最长字串，你的窗口长度大于哈希表的长度，则一定含有重复元素，因此更新左边界，使用if
		{
			.....
		}
		//(2)： 滑动窗口的长度不固定，使用while来更新窗口	
		if (right>=k-1)//举个例子：子数组的最大平均值，子数组规定长度不能超过k，因此滑窗长度固定
		{
			.....
		}
		right++;//此处可以改为for循环
	}
	return res;//Step5: 返回结果
}

经典例题

3. 无重复字符的最长字串

传送门：
https://leetcode.cn/problems/longest-substring-without-repeating-characters/

Step4： 滑动窗口不具有固定长度，所以使用while循环来更新滑动窗口

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        //1. 确定维护变量：存储字符个数的哈希表
        unordered_map<char,int> m;
        int max_len=0;
        //2. 定义滑动窗口的边界，开始滑动窗口
        int n=s.size();
        int left=0,right=0;
        while (right<n)
        {
            //3. 合法更新：哈希表存储字符的更新，字符放到哈希表中
            m[s[right]]++;
            if (right-left+1==m.size())
            {
                max_len=max(max_len,right-left+1);
            }
            //4. 非法更新：窗口的长度小于哈希表的长度
            //想象一下：哈希表存储每个字符，如果遇到相同的字符则长度不变，但是窗口的长度会变，因此就造成了窗口里有重复的单词，非法了，需要更新窗口的左边界，必要时删除此字符
            while (right-left+1>m.size())
            {
                m[s[left]]--;
                if (m[s[left]]==0)
                {
                    m.erase(s[left]);
                }
                left++;
            }
            right++;
        }
        //5. 返回结果
        return max_len;
    }
};

643. 子数组最大平均数 I

传送门：
https://leetcode.cn/problems/maximum-average-subarray-i/

Step4：滑动窗口的长度固定：为k ，使用 if条件来更新滑动窗口

class Solution {
public:
    double findMaxAverage(vector<int>& nums, int k) {
        //1. 定义维护变量
        int sum=0;
        int res=INT_MIN;
        //2. 确定滑动窗口的左右边界，开始滑动窗口
        int left=0,right=0;
        int n=nums.size();
        while (right<n)
        {
            //3. 合法更新：滑动每一步，只要滑动的长度等于k，则记录一下此时的sum值
            sum+=nums[right];
            if (right-left+1==k)
            {
                res=max(res,sum);
            }
            //4. 非法更新：滑动窗口的长度固定，使用if来更新，
            if (right>=k-1)
            {
                sum-=nums[left];
                left++;
            }
            right++;
        }
        return static_cast<double>(res)/k;
    }
};

159. 至多包含两个不同字符的最长子串

传送门：
https://leetcode-cn.com/problems/longest-substring-with-at-most-two-distinct-characters/

Step4：滑动窗口长度不固定： 使用 while循环来更新滑动窗口

//至多包含两个不同字符的最长字串
class Solution_159 {
public:
	int lengthOfLongestSubstringTwoDistinct(string s) {
		//1. 定义维护变量
		unordered_map<char, int> m;
		int len = 0;

		//2. 确定窗口的左右边界，开始滑动窗口
		int left = 0, right = 0;
		int n = s.size();
		while (right < n)
		{
			//3. 合法更新：滑动过程中map存储每一个字符
			m[s[right]]++;
			if (m.size() <= 2)
			{
				len = max(len, right - left + 1);
			}
			//4. 非法更新：最多存储两个不同的字符，但是对于每种字符的存储数量没有限制，因此可以存储很多很多，但是不能超过两种，所以滑动窗口的长度不固定 使用while来更新滑动窗口
			// 哈希表的长度大于3，则至少出现了3种不同的字符，因此窗口不合法， 需要更新
			while (m.size() > 2)	// right >= k-1
			{
				m[s[left]]--;
				if (m[s[left]] == 0)
				{
					m.erase(s[left]);
				}
				left++;
			}
			right++;
		}
		return len;
	}
};

209. 长度最小的子数组

传送门：
https://leetcode.cn/problems/minimum-size-subarray-sum/

Step4：滑动窗口长度不固定： 使用 while循环来更新滑动窗口

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int sum=0;
        int len=INT_MAX;
        int left=0,right=0;
        int n=nums.size();
        while (right<n)
        {
        	//3. 合法更新，窗口滑动一下，把这个数字想加，计算之和
            sum+=nums[right];
            //4. 非法更新（二次更新）：当sum满足条件时，试探是否有更好的办法可以实现，即缩小窗口，有没有长度更小的子数组满足>=target
            while (sum>=target)
            {
                len=min(len,right-left+1);
                sum-=nums[left];
                left++;
            }
            right++;
        }
        return (len==INT_MAX)?0:len;
    }
};

1695. 删除子数组的最大得分

传送门：
https://leetcode.cn/problems/maximum-erasure-value/

Step4：滑动窗口长度不固定： 使用 while循环来更新滑动窗口

class Solution {
public:
    int maximumUniqueSubarray(vector<int>& nums) {
        unordered_map<int,int> m;
        int sum=0;
        int res=0;
        int left=0,right=0;
        int n=nums.size();
        while (right<n)
        {
            //3. 合法更新： sum每次相加,并且记录当前字符的种类，如果字符种类等于滑动窗口的长度，则滑动窗口出现的字符种类都等于哈希表里存储的种类，满足条件，相加，保存结果
            m[nums[right]]++;
            sum+=nums[right];
            if (right-left+1==m.size())
            {
                res=max(res,sum);
            }
            //4. 非法更新： 滑动窗口长度大于哈希表的长度
            //说明滑动窗口里有重复元素出现，则左边界收缩，哈希表删除左边界元素，进行窗口的更新
            while (right-left+1>m.size())
            {
                sum-=nums[left];
                m[nums[left]]--;
                if (m[nums[left]]==0)
                {
                    m.erase(nums[left]);
                }
                left++;
            }
            right++;
        }
        return res;
    }
};

438. 找到字符串中所有字母异位词

传送门：
https://leetcode.cn/problems/find-all-anagrams-in-a-string/

Step4：滑动窗口长度固定： 使用 if条件来更新滑动窗口

class Solution {
private:
    unordered_map<char,int> m_s;
    unordered_map<char,int> m_p;
public:
    vector<int> findAnagrams(string s, string p) {
        for (auto& x:p)
        {
            m_p[x]++;
        }
        int left=0,right=0;
        int n1=s.size();
        int n2=p.size();

        vector<int> vec;
        while (right<n1)
        {
        	//3. 合法更新： 窗口滑动，字符存储入哈希表
            m_s[s[right]]++;
            //当哈希表的元素存储和目标p完全一致。则left起始下标就是一个目标下标
            if (m_s == m_p)
            {
                vec.push_back(left);
            }
            //4. 非法更新：滑动窗口有固定长度，长度为p的长度，因此使用if条件来维护
            if (right>=n2-1)
            {
                m_s[s[left]]--;
                if (m_s[s[left]]==0)
                {
                    m_s.erase(s[left]);
                }
                left++;
            }
            right++;
        }
        return vec;
    }
};

567. 字符串的排列

传送门：
https://leetcode.cn/problems/permutation-in-string/description/

Step4：滑动窗口长度固定： 使用 if条件来更新滑动窗口

class Solution {
public:
    bool checkInclusion(string s1, string s2) {
        unordered_map<char,int> m_s1;
        unordered_map<char,int> cnt;   
        for (auto& x:s1)
        {
            m_s1[x]++;
        }
        int left=0,right=0;
        int n1=s1.size();
        int n2=s2.size();
        while (right<n2)
        {
        	//3. 合法更新：存储字符串到哈希表中，然后与目标哈希表存储元素进行比较
            cnt[s2[right]]++;
            if (cnt==m_s1)
            {
                return true;
            }
            //4. 非法更新：滑动窗口长度固定，更新维护变量，缩短左边界
            if (right>=n1-1)
            {
                cnt[s2[left]]--;
                if (cnt[s2[left]]==0)
                {
                    cnt.erase(s2[left]);
                }
                left++;
            }
            right++;
        }
        return false;
    }
};

76.最小覆盖子串

  1. m_t哈希表存储要覆盖的字符串t的字符
  2. m_s存储滑动窗口每次滑动时添加的字符及次数
  3. 判断m_s是否含有m_t，即s字符串包含t字符串，如果它包含，那么进行接下来的二次更新
  4. 二次更新：左边界left右移，m_s哈希表存储的这个left字符计数减一，为0时则直接删除，进而达到缩小窗口的目的。同时，每缩小一次，我们记录此时的长度len和开始位置start，我们的len要取得每次的最小值，则len就是最小覆盖子串的长度，start就是其起始下标。

注意：最小覆盖字串的长度是不固定的，因此，Step4： 我们要使用while循环来更新滑动窗口。

class Solution {
private:
	unordered_map<char, int> m_s;
	unordered_map<char, int> m_t;
public:
	bool check()
	{
		for (auto& x : m_t)
		{
			if (m_s[x.first] < x.second)
			{
				return false;
			}
		}
		return true;
	}
	string minWindow(string s, string t) {
		//1. 确定维护的变量，是一个哈希表，存储t中的字符
		for (auto& x : t)
		{
			m_t[x]++;
		}
		string res;
		int len = INT_MAX;      //记录字符串长度
		int start = -1;         //目标字符串序列位置
		//2. 定义滑动窗口边界，开始滑动窗口
		int left = 0, right = 0;
		int n = s.size();
		while (right < n)
		{
			//3. 合法更新：滑动窗口每移动一次，字符就放进哈希表中
			m_s[s[right]]++;
			//4. 非法更新:无固定长度，使用while循环，每次使得t串能够包含于s串中
			//并且要尽量让s串取到《最小包含》，因此每次都更新左边界，试探是否有最小的包含，并且更新滑动窗口
			while (check() && left <= right)
			{
				if (right - left + 1 <= len)
				{
					len = right - left + 1;
					start = left;
				}
				m_s[s[left]]--;
				if (m_s[s[left]] == 0)
				{
					m_s.erase(s[left]);
				}
				left++;
			}
			right++;
		}
		//5. 返回结果
		return (start == -1) ? "" : s.substr(start, len);
	}
};

2022年12月27日补充：

713. 乘积小于K的子数组

力扣传送门：
https://leetcode.cn/problems/subarray-product-less-than-k/description/?envType=study-plan&id=suan-fa-ji-chu&plan=algorithms&plan_progress=y00ve32

返回数组中某些元素的乘积小于K的子数组的个数：
该题目没有固定的范围，因此使用while循环，无固定次数的滑动窗口

在这里插入图片描述

class Solution {
public:
    int numSubarrayProductLessThanK(vector<int>& nums, int k) {
        int res=0;
        int left=0,right=0;
        int n=nums.size();
        int cst=1;
        while (right<n)
        {
            cst*=nums[right];
            while (left<=right && cst>=k)
            {
                cst/=nums[left];
                left++;
            }
            if (cst<k)
            {
                res+=right-left+1;
            }
            right++;
        }

        return res;
    }
};
Yuleo_
关注
  • 5
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
C++滑动窗口问题汇总
03-05
包含题目、解答思路、模板和答案
滑动窗口的概要介绍与分析
05-03
滑动窗口（Sliding Window）是一种在计算机科学中广泛应用的算法技术，尤其在处理数据流、字符串匹配、数组运算等场景中发挥着重要作用。滑动窗口技术的基本思想是通过维护一个固定大小的窗口，在数据流或数据集合上...
2024年C C++最全【滑动窗口】leetcode904(1)，2024年最新字节跳动8年老C C++面试官经验谈
2401_84973631的博客
05-13 296
如下图所示：在我们维护两指针的过程中，像一个窗口在滑动，于是就被起名叫滑动窗口类型的题型。其实也就是双指针。注意滑动窗口的窗口，此处虽然画的是固定长度，但是对于这类题目来说，可以分为固定长度的滑动窗口问题和不固定长度的滑动窗口我们为什么需要使用滑动窗口呢？话不多说，我们从题目中体会吧！
C++ 滑动窗口
m0_74922218的博客
03-02 1138
滑动窗口，哈希，动态窗口，静态窗口，语法："++" "--"
【c++算法篇】滑动窗口
最新发布
Quietcoder的博客
05-16 1113
1.长度最小的子数组🔥个人主页Quitecoder🔥算法笔记仓。
c++滑动窗口
2301_76180325的博客
12-02 810
C++中实现滑动窗口，可以使用双指针法。双指针法适用于有序数组或者字符串的问题，可以将时间复杂度从O(n^2)优化到O(n)。具体实现步骤如下：1. 定义left和right两个指针，分别指向滑动窗口的左右边界。2. 当滑动窗口满足条件时，不断移动右指针，扩大窗口。3. 当滑动窗口不再满足条件时，不断移动左指针，缩小窗口。4. 在滑动窗口的过程中，记录窗口中的最大值或者最小值，即为问题的解。
76. 最小覆盖子串 滑动窗口
qq_45638271的博客
07-20 465
给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串，则返回空字符串 “” 。 注意： 对于 t 中重复字符，我们寻找的子字符串中该字符数量必须不少于 t 中该字符数量。 如果 s 中存在这样的子串，我们保证它是唯一的答案。 示例 1： 输入：s = “ADOBECODEBANC”, t = “ABC” 输出：“BANC” 示例 2： 输入：s = “a”, t = “a” 输出：“a” 示例 3: 输入: s = “a”, t = “
滑动窗口 c++
m0_68416190的博客
07-27 316
我们发现，当新元素比原来窗口的一些元素要小时，那么这些元素就是没有用的元素，因为它们的位置在新元素之前，会比新元素提前被推出滑动窗口，同时由于新元素比这些元素要小，这些元素永远不会被当做最小值输出。而当最小值不在新窗口中时，即队列中第一个元素对应的数组元素不在新窗口时，我们把队头元素推出，这时新的队头对应的数组元素再先新元素比较，如果新元素不是最小值，就把它的下标放到队列的适当位置。一个简单的思路，就是在每一个滑动窗口中，遍历一次滑动窗口中的数，找到滑动窗口中的最大值和最小值，并用两个数组把它们存起来。
C++算法：滑动窗口总结
闻缺陷则喜何志丹
01-01 1325
滑动窗口。
滑动窗口——单调队列(C/C++)
psudd的博客
10-12 943
滑动窗口问题：问题分析+代码求解
滑动窗口生成样本MATLAB程序
05-01
找了好久的滑动窗口的程序都不符合我的要求，看到几篇机器学习的文章都是用滑动窗口生成的样本数据，最近同学给我搞了一个，现在分享给大家，程序为matlab编写，可以直接对原始采集数据生成所需样本，已经封装成了...
c++算法设计-滑动窗口
10-12
栈的基本操作c
滑动窗口技巧进阶.md
08-14
主要介绍了滑动窗口算法的寄到leetcode题目，然后进行技巧总结
C++实现三种滤波算法（过程详细）
qq_59744114的博客
12-02 7666
由于本人并未了解过代码优化相关知识，因此本文代码仅是能够实现滤波算法的功能，效果验证通过Python语言。代码根据相关滤波算法定义而写。
[滑动窗口/卡尔曼滤波]用C++/ROS写一个简单的速度滤波器
qq_43553302的博客
08-26 565
在ROS相关的小车进行导航时，往往会使用navigation包里的move_base作为小车的速度输出。move_base为我们内置了一些局部路径规划器如dwa和teb等，但这些速度规划器的输出可能不够平滑，因此我们可以使用速度滤波器来改善这些情况
数据结构——滑动窗口（例题来源AcWing）
weixin_72758935的博客
04-13 110
单调队列模板
数据结构算法——滑动窗口问题（以LeetCode滑动窗口题为例）
枫陵的博客
06-05 3816
1. 滑动窗口 滑动窗口算法是在给定特定窗口大小的数组或字符串上执行要求的操作，它的原理与网络传输TCP协议中的滑动窗口协议（Sliding Window Protocol）基本一致。 这种技术可以将一部分问题中的嵌套循环转变为一个单循环，因此它可以减少时间复杂度。滑动窗口主要应用在数组和字符串上。 例如，设定滑动窗口（window）大小为 3，当滑动窗口每次划过数组时，计算当前滑动窗口中元素的和，可以得到一组结果 res。 因为滑.........
趣味算法：滑动窗口算法的理解与应用
沐雨风栉
06-27 2181
在编程和数据结构中，滑动窗口算法是一种常见的解决问题的方法。它主要用于处理涉及连续或固定长度子数组、子序列或子字符串的问题。本文将深入探讨滑动窗口算法，包括其基本概念、应用场景、基本步骤以及具体的Java代码实践。滑动窗口算法是一种优化技巧，主要用于解决数组或链表中的子序列或子串问题。其主要优势是能够将一些复杂问题的时间复杂度降低至线性。滑动窗口是一种高效的算法优化策略，适用于解决各种需要处理连续子序列或子数组问题的场景。
力扣刷题总结笔记——滑动窗口
weixin_53432918的博客
08-05 176
我们平常做题的时候只要看到是和子串相关的题目我们就要第一时间想到是不是滑动窗口题目，一般的子串都是用和双指针进行解决，还有一个前缀和。
滑动窗口协议的模拟C++
06-08
好的，以下是一个简单的滑动窗口协议的模拟 C++ 代码： ``` #include <iostream> #include <cstring> #include <cstdlib> #include <ctime> #define WINDOW_SIZE 4 // 滑动窗口大小 #define FRAME_SIZE 20 // 帧大小 using namespace std; struct frame { int seq_num; // 序列号 char data[FRAME_SIZE]; // 数据 }; int main() { int i, j, k; int ack_num, send_base, next_frame_to_send, frame_expected; frame sending_window[WINDOW_SIZE], current_frame; ack_num = send_base = next_frame_to_send = frame_expected = 0; // 模拟发送端 for (i = 0; i < 8; i++) { // 发送 8 个帧 // 构造当前帧 current_frame.seq_num = next_frame_to_send; for (j = 0; j < FRAME_SIZE; j++) { current_frame.data[j] = 'a' + next_frame_to_send % 26; } cout << "发送帧 " << current_frame.seq_num << endl; // 把当前帧放入发送窗口 sending_window[next_frame_to_send % WINDOW_SIZE] = current_frame; next_frame_to_send++; // 发送窗口已满，等待 ACK if (next_frame_to_send == send_base + WINDOW_SIZE) { cout << "发送窗口已满，等待 ACK..." << endl; // 等待 ACK while (ack_num < next_frame_to_send) { cout << "等待 ACK " << ack_num << endl; // 接收到 ACK if (ack_num == frame_expected) { cout << "接收到 ACK " << ack_num << endl; send_base++; frame_expected++; } ack_num++; } } } // 模拟接收端 srand(time(NULL)); for (k = 0; k < 8; k++) { // 接收 8 个帧 // 模拟丢失帧 if (rand() % 10 < 3) { cout << "丢失帧 " << frame_expected << endl; } else { // 接收到正确的帧 cout << "接收到帧 " << frame_expected << endl; ack_num = frame_expected; // 发送 ACK if (rand() % 10 >= 3) { cout << "发送 ACK " << ack_num << endl; frame_expected++; } } } return 0; } ``` 该代码与前面的 C 语言代码相似，不同之处在于使用了 C++ 的输入输出流和字符串处理函数。注意，该代码仅供参考，实际使用时应该根据具体需求进行修改和优化。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Yuleo_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值