算法思想总结:滑动窗口算法

简介: 算法思想总结:滑动窗口算法

                                                    创作不易,感谢三连

一.长度最小的数组

. - 力扣(LeetCode)长度最小的数组

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) 
    {
           int len=INT_MAX,n=nums.size(),sum=0;//len必须要给一个很大的数,否则
           for(int left=0,right=0;right<n;++right)
           {
            sum+=nums[right];//right进窗口
            while(sum>=target)//符合条件后进行更新,然后出窗口
            {
                len=min(len,right-left+1);//更新长度
                sum-=nums[left++];
            }
           }
           return len==INT_MAX?0:len;
    }
};

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

. - 力扣(LeetCode)无字符的最长字串

class Solution {
public:
    int lengthOfLongestSubstring(string s) 
    {
        int hash[128]={};//计数
        int len=0, n=s.size();
        for(int left=0,right=0;right<n;++right)
        {
            ++hash[s[right]];//进窗口
            while(hash[s[right]]>1)  --hash[s[left++]];//出窗口
            len=max(len,right-left+1);//更新长度
        }
        return len;
    }
};

三.最大连续1的个数

. - 力扣(LeetCode)最大连续1的个数

class Solution {
public:
    int longestOnes(vector<int>& nums, int k)
    {
         int len=0;
         for(int left=0,right=0,zero=0;right<nums.size();++right)
            {
                if(nums[right]==0) ++zero;//进窗口
                while(zero>k) if(nums[left++]==0) --zero;//出窗口
                len=max(len,right-left+1); 
            }
            return len;
    }
};

四.将x减到0的最小操作数

. - 力扣(LeetCode)将x减到0的最小操作数

class Solution {
public:
    int minOperations(vector<int>& nums, int x) 
    {//将问题转化为求一个最长子数组 其大小正好==sum-x
        int ret=-1;
        int sum=accumulate(nums.begin(),nums.end(),0);//计算数组的总和
        int target=sum-x;//记录目标值
        if(target<0) return -1;//细节处理
        for(int left=0,right=0,temp=0,n=nums.size();right<n;++right)
        {
            temp+=nums[right];//进窗口
            while(temp>target)  temp-=nums[left++];//出窗口
            if(temp==target)   ret=max(ret,right-left+1);//更新结果
        }
        return ret==-1?-1:nums.size()-ret;
    }
};

五.水果成篮

. - 力扣(LeetCode)水果成篮

class Solution {
public:
    int totalFruit(vector<int>& fruits) 
    {
       int hash[100001]={0};
       int ret=0,n=fruits.size();
       for(int left=0,right=0,kinds=0;right<n;++right)
       {
           if(hash[fruits[right]]++==0) ++kinds;//进窗口
           while(kinds>2)  if(--hash[fruits[left++]]==0) --kinds;
           ret=max(ret,right-left+1);
       }
       return ret;
    }
};

六.找到字符串种所有字母异位词

. - 力扣(LeetCode)找到字符串种所有字母异位词

class Solution {
public:
    vector<int> findAnagrams(string s, string p) 
    {
        vector<int> ret;
        int hash1[26]={0};//用来统计p的元素个数
        for(char ch:p) ++hash1[ch-'a'];
        int hash2[26]={0};//用来统计滑动窗口的元素个数
        int m=p.size();
        for(int left=0,right=0,count=0;right<s.size();++right)//count用来记录有效字符的个数
           {
            char in=s[right];
           if(++hash2[in-'a']<=hash1[in-'a'])  ++count;//进窗口的同时统计有效字符个数
            if(right-left+1>m)//判断  出窗口
            {
                char out=s[left++];
               if(hash2[out-'a']--<=hash1[out-'a'])  --count;
            }
            if(count==m) ret.push_back(left);
           }
           return ret;
    }
};

七.最小覆盖字串

. - 力扣(LeetCode)最小覆盖字串

class Solution {
public:
    string minWindow(string s, string t) 
    {
        int hash1[128]={0};//统计t字符串个元素的出现次数
        int kinds=0;//用来统计种类
        for(char ch:t) if(hash1[ch]++==0)  ++kinds;
        int hash2[128]={0};//统计s字符串中滑动窗口的元素出现次数
        int begin=-1,minlen=INT_MAX;//用来记录返回值情况
        for(int left=0,right=0,count=0;right<s.size();++right)
        {
            if(++hash2[s[right]]==hash1[s[right]])  ++count;//进窗口的同时统计窗口内元素种类
            while(count==kinds)//当种类都一样时,可以去更新结果
            {
                if(right-left+1<minlen)//因为还需要更新begin,所以不能直接用min
                {
                    minlen=right-left+1;
                    begin=left;
                }
                if(hash2[s[left]]--==hash1[s[left]]) --count;
                ++left;
            }
        }
         return begin==-1?"":s.substr(begin,minlen);
    }
};

八.串联所有单词的子串

. - 力扣(LeetCode)串联所有单词的子串

 

class Solution {
public:
    vector<int> findSubstring(string s, vector<string>& words) 
    {
        int m=words.size();//单词个数
        int len=words[0].size();//每个单词的长度
        vector<int> ret;//用来返回
        unordered_map<string,int> hash1;//用来记录word的各个单词出现次数
        for(auto s:words) ++hash1[s];
        for(int i=0;i<len;++i)//要使用len次滑动窗口
        {
             unordered_map<string,int> hash2;//用来记录滑动窗口的各个单词出现次数
           for(int left=i,right=i,count=0;right+len-1<s.size();right+=len)//count用来有效子串
           {
                string in=s.substr(right,len);
                if(++hash2[in]<=hash1[in])  ++count;//进窗口顺便维护count
                if(right-left+1>len*m)//如果超过窗口的大小,就要出窗口
                {
                    string out=s.substr(left,len);
                    if(hash2[out]--<=hash1[out]) --count; //出窗口前要先维护count
                    left+=len;//出窗口要更新left
                }
                if(count==m) ret.push_back(left);//如果count==m,说明有效子串达到要求
           }
        }
        return ret;
    }     
};

九.滑动窗口总结

  当题目涉及到子串或者是子数组,都可以考虑到使用滑动窗口来进行解决

   但是有一个需要注意的地方就是如果涉及到窗口求和的话。要保证数都是正整数,否则就不满足单调性如下图这一题

涉及到不同的种类需要统计数量的时候,常常会用到哈希表!! (5-7题)

后面有类似题目会持续更新!!

相关文章
|
算法
【算法】滑动窗口——最大连续1的个数
【算法】滑动窗口——最大连续1的个数
138 0
|
5月前
|
机器学习/深度学习 监控 算法
员工上网行为监控软件中基于滑动窗口的C#流量统计算法解析​
在数字化办公环境中,员工上网行为监控软件需要高效处理海量网络请求数据,同时实时识别异常行为(如高频访问非工作网站)。传统的时间序列统计方法因计算复杂度过高,难以满足低延迟需求。本文将介绍一种基于滑动窗口的C#统计算法,通过动态时间窗口管理,实现高效的行为模式分析与流量计数。
125 2
|
3月前
|
存储 机器学习/深度学习 监控
公司电脑上网监控中滑动窗口算法的理论构建与工程实现
本文提出一种基于滑动窗口算法的实时网络流量监控框架,旨在强化企业信息安全防护体系。系统采用分层架构设计,包含数据采集、处理与分析决策三大模块,通过 Java 实现核心功能。利用滑动窗口技术动态分析流量模式,结合阈值检测与机器学习模型识别异常行为。实验表明,该方案在保证高检测准确率的同时支持大规模并发处理,为企业数字化转型提供可靠保障。
81 0
|
5月前
|
存储 机器学习/深度学习 监控
如何监控员工的电脑——基于滑动时间窗口的Java事件聚合算法实现探析​
在企业管理场景中,如何监控员工的电脑操作行为是一个涉及效率与合规性的重要课题。传统方法依赖日志采集或屏幕截图,但数据量庞大且实时性不足。本文提出一种基于滑动时间窗口的事件聚合算法,通过Java语言实现高效、低资源占用的监控逻辑,为如何监控员工的电脑提供一种轻量化解决方案。
122 3
|
6月前
|
存储 监控 算法
基于 PHP 语言的滑动窗口频率统计算法在公司局域网监控电脑日志分析中的应用研究
在当代企业网络架构中,公司局域网监控电脑系统需实时处理海量终端设备产生的连接日志。每台设备平均每分钟生成 3 至 5 条网络请求记录,这对监控系统的数据处理能力提出了极高要求。传统关系型数据库在应对这种高频写入场景时,性能往往难以令人满意。故而,引入特定的内存数据结构与优化算法成为必然选择。
132 3
|
算法
【算法】滑动窗口——最小覆盖子串
【算法】滑动窗口——最小覆盖子串
107 0
|
算法
【算法】滑动窗口——找到字符串中所有字母异位词
【算法】滑动窗口——找到字符串中所有字母异位词
162 0
|
算法
【算法】滑动窗口——将x减到0的最小操作数
【算法】滑动窗口——将x减到0的最小操作数
121 0
|
算法
【算法】滑动窗口——无重复字符的最长子串
【算法】滑动窗口——无重复字符的最长子串
|
算法
【算法】滑动窗口——长度最小的子数组
【算法】滑动窗口——长度最小的子数组
133 0

热门文章

最新文章