滑动窗口集合

最新推荐文章于 2023-01-07 18:39:37 发布
最新推荐文章于 2023-01-07 18:39:37 发布
阅读量208 收藏
点赞数
分类专栏： 算法编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CsWarmSun/article/details/113734767
版权

概述

一种非常典型的编程思想，滑动窗口。

专门针对滑动窗口的问题，框架更是一看就懂。

while (right < s.length()) {
    //移动窗口右边时机，向窗口添加元素
    w.add(s.charAt(right++));
    // 判断是否需要移动窗口坐标，移除元素
    while (w.check()) {
        w.remove(s.charAt(left++));
    }
    // debug时机，查看当前窗口，或打印窗口内容
    // 检查合法条件时机，以下为举例
    size = Math.max(size, w.size);
}

这个框架的好处是非常清晰，主要逻辑——添加元素，删除元素，检查合法性，用什么来帮助快速检查合法性都交给窗口。窗口对象需要实现这些方法。

窗口类型

固定窗口

特点是left和right一同移动。

567. Permutation in String
    1. Permutation in String
  • s2是否包含s1的全排列
  • https://leetcode.com/problems/permutation-in-string/

以这道题是我做的第一道题，将进行详细展开。如果不以滑动窗口的方式去考虑问题，那这种题会变得很麻烦。优化策略很多，也不好实现。

我一开始考虑到的解法：

for c in s2:
	if 当前子串是否等于s1的全排列之一
        记录下标

复杂度主要来源于if的判断。

解法一：暴力

全排列，只需要所有字母一致即可，暴力遍历即可求解。

  • 时间复杂度：O(N M ^ 2), O(M ^ 2)为两个for循环，在当前子串中搜索s1的所有字母
  • 空间复杂度，O(1)

解法二：排序

上面O（M^2）有待优化，既然求是否全排列之一，那么就可以对其排序，那就可以直接在O(M)比出结果

  • 时间复杂度，O(N M log M)，主要是排序开销
  • 空间复杂度，O(1)

解法三：hash

能否在O(1)求解是否为全排列之一？s1不需要每次都遍历一遍。可以将s1的全排列的所有可能都放入hash table中，然后遍历，每次判断当前子串的时候只需要判断它在不在hash table中即可。

  • 时间复杂度，O(N M)，很遗憾即使有hash table，每次判断在不在hash table，这个操作也是O(M)而不是hash查找的O(1)，这也是常见的误区之一，核心原因是因为hash函数的求取直接和s1长度M挂钩。
  • 空间复杂度，O(M!)，指数级复杂度，等于s1的全排列。

看到了吧，以上种种方式都似乎指出该问题不简单，不管是复杂度还是实现上。但该问题其实有时间上O(1)空间上O(M)的高效解法。这就是滑动窗口的强大。

解法四：滑动窗口

滑动窗口的优化核心是窗口滑动新增一个元素（删除一个元素），这意味着不需要完全遍历，有O(1)解决问题的潜力，只要能很好利用旧窗口的知识。

所以，实现窗口也就是如何利用已有信息，更新新的信息。

对于本题，窗口利用hash桶，记录出现过的字符。新增元素则加一，移除元素则减一。若所有桶都为0，则表示当前字符串和s1的字符完全一致。

/*
全新滑动窗口框架
Runtime: 9 ms, faster than 52.34% of Java online submissions for Permutation in String.
Memory Usage: 40.2 MB, less than 8.87% of Java online submissions for Permutation in String.
* */
public class SolutionV2 {
    public boolean checkInclusion(String s1, String s2) {
        int l,r;
        l = r = 0;
        Window w = new Window(s1);
        while (r < s2.length()) {
            w.add(s2.charAt(r++));
            if (r > w.size) {
                w.remove(s2.charAt(l++));
            }
            // System.out.println(l+ " " + r);
            // w.disp();
            if (w.check()) return true;
        }

        return false;
    }

    // public static void main(String[] args) {
    //     System.out.println(new SolutionV2().checkInclusion(
    //             "a",
    //             "a"));
    // }

    class Window {

        int[] map;

        int size, count;

        public Window(String target) {
            map = new int[130];
            this.size = target.length();
            for (int i = 0; i < size; ++i) {
                if (map[target.charAt(i)]++ == 0) ++count;
            }
        }

        public void add(char c) {
            if (--map[c] == 0) --count;
        }

        public void remove(char c) {
            if (map[c]++ == 0) ++count;
        }

        public boolean check() {
            if (count == 0) return true;
            return false;
        }

        public void disp() {
            for (int i = 'A'; i <= 'z'; i++) {
                System.out.print(map[i] + " ");
            }
            System.out.println();
        }
    }
}
438. Find All Anagrams in a String
    1. Find All Anagrams in a String
  • 寻找所有异构字串起始下标
  • https://leetcode.com/problems/find-all-anagrams-in-a-string/

和上一道题基本完全一致。

package com.leetcode.datastructure.array.window.q438;

import java.util.ArrayList;
import java.util.List;

/*
 * 438. Find All Anagrams in a String
 * 寻找所有异构字串起始下标
 * https://leetcode.com/problems/find-all-anagrams-in-a-string/
 * */

/*
滑动窗口
时间复杂度，O(N)
滑动遍历N个字符，由于hash，异构字符串判断为O(1)
空间复杂度，O(K)，K为不同字符数
Runtime: 7 ms, faster than 76.50% of Java online submissions for Find All Anagrams in a String.
        Memory Usage: 39.5 MB, less than 98.83% of Java online submissions for Find All Anagrams in a String.
*/

class Solution {
    public List<Integer> findAnagrams(String s, String p) {
        int left, right;
        Window w = new Window(p);
        List<Integer> res = new ArrayList<>();
        left = right = 0;
        while (right < s.length()) {
            w.add(s.charAt(right++));
            if (right > w.size) {
                w.remove(s.charAt(left++));
            }
            // w.disp();
            if (w.check()) res.add(left);
            // System.out.println(left + " " + right );
        }
        return res;
    }

    // public static void main(String[] args) {
    //     System.out.println(new Solution().findAnagrams("cbaebabacd",
    //             "abc"));
    // }

    class Window {

        int[] map;

        int size, count;

        public Window(String target) {
            map = new int[130];
            this.size = target.length();
            for (int i = 0; i < size; ++i) {
                if (map[target.charAt(i)]++ == 0) ++count;
            }
        }

        public void add(char c) {
            if (--map[c] == 0) --count;
        }

        public void remove(char c) {
            if (map[c]++ == 0) ++count;
        }

        public boolean check() {
            if (count == 0) return true;
            return false;
        }

        public void disp() {
            for (int i = 'A'; i <= 'z'; i++) {
                System.out.print(map[i] + " ");
            }
            System.out.println();
        }
    }
}

不定长窗口

76. Minimum Window Substring
    1. Minimum Window Substring
  • 寻找包含目标字所有字母的最小子串
  • https://leetcode.com/problems/minimum-window-substring/

和567非常像。

版本一，想当然地遍历了所有可能的窗口大小，因此算法复杂度为O(N^2)。但实际上，该类问题属于不定长窗口，不需要遍历所有窗口。它的基本思想是：移动右边，直到符合要求，才开始移动左边。采用双指针的方式，可以在O（N）的时间内解决问题，非常经典。

/*
* 76. Minimum Window Substring
* 寻找包含目标字所有字母的最小子串
* https://leetcode.com/problems/minimum-window-substring/
*
* */

/*
算法复杂度，O(N N) + O(N M)
其中N，M分别为s，t的长度。
里层如q567，O(N) + O(M),重复N次。
空间复杂度，O(M + K)
K为桶固定常数开销。
Runtime: 871 ms, faster than 5.02% of Java online submissions for Minimum Window Substring.
Memory Usage: 39.5 MB, less than 54.77% of Java online submissions for Minimum Window Substring.
*/

class Solution {
    public String minWindow(String s, String t) {
        for (int n = t.length(); n <= s.length(); ++n) {
            Window w = new Window(t, n);
            for (int i = 0; i < s.length(); ++i) {
                if (i < w.size) {
                    w.add(s.charAt(i));
                } else {
                    w.remove(s.charAt(i - w.size));
                    w.add(s.charAt(i));
                }
                System.out.println(s.charAt(i));
                w.disp();
                if (w.check()) return s.substring(i-w.size+1,i+1);
            }
            System.out.println("=============");
        }
        return "";
    }

    public static void main(String[] args) {
        System.out.println(new Solution().minWindow("a"
                , "a"));
    }
}

class Window {

    int[] map;

    int size, count;

    public Window(String target, int size) {
        map = new int[130];
        this.size = size;
        for (int i = 0; i < target.length(); ++i) {
            if (map[target.charAt(i)]++ == 0) ++count;
        }
    }

    public void add(char c) {
        if (--map[c] == 0) --count;
    }

    public void remove(char c) {
        if (map[c]++ == 0) ++count;
    }

    public boolean check() {
        if (count == 0) return true;
        return false;
    }

    public void disp() {
        for (int i = 'A'; i <= 'z'; i++) {
            System.out.print(map[i]+" ");
        }
        System.out.println();
    }
}

版本二：

/*
全新框架，单边收缩版本
Runtime: 4 ms, faster than 83.81% of Java online submissions for Minimum Window Substring.
Memory Usage: 40.9 MB, less than 13.46% of Java online submissions for Minimum Window Substring.
*/
public class SolutionV2 {

    public String minWindow(String s, String t) {
        int left, right, rl, rr;
        Window w = new Window(t);
        left = right = 0;
        rl = 0;
        rr = Integer.MAX_VALUE;
        // 移动右边
        while (right < s.length()) {
            w.add(s.charAt(right++));
            // 收缩左边
            if (w.check()) {
                while (w.check()) {
                    w.remove(s.charAt(left++));
                    // System.out.println(left + " " + right);
                }
                if (rr - rl > right - left + 1) {
                    rr = right;
                    rl = left - 1;
                }
            }

        }

        return rr == Integer.MAX_VALUE ? "" : s.substring(rl, rr);
    }

    // public static void main(String[] args) {
    //     System.out.println(new SolutionV2().minWindow("ADOBECODEBANC"
    //             , "ABC"));
    // }

    class Window {

        int[] map;

        int size, count;

        public Window(String target) {
            map = new int[130];
            this.size = target.length();
            for (int i = 0; i < size; ++i) {
                if (map[target.charAt(i)]++ == 0) ++count;
            }
        }

        public void add(char c) {
            if (--map[c] == 0) --count;
        }

        public void remove(char c) {
            if (map[c]++ == 0) ++count;
        }

        public boolean check() {
            if (count == 0) return true;
            return false;
        }

        public void disp() {
            for (int i = 'A'; i <= 'z'; i++) {
                System.out.print(map[i] + " ");
            }
            System.out.println();
        }
    }
}
3. Longest Substring Without Repeating Characters
    1. Longest Substring Without Repeating Characters
  • 不重复的最长字串
  • https://leetcode.com/problems/longest-substring-without-repeating-characters/

这个问题和问题76不太一样，窗口需要重写，但同样属于不定长窗口。

/*
* 3. Longest Substring Without Repeating Characters
* 不重复的最长字串
* https://leetcode.com/problems/longest-substring-without-repeating-characters/
*
* */

/*
滑动窗口的思想下，非常简单
移动右边，直到出现重复，则开始移动左边，直到不再重复。
时间复杂度 o(n)，hash加持下下，重复判断只需要O(1)
空间复杂度 o（k），k为不同字符个数，常数
Runtime: 5 ms, faster than 81.47% of Java online submissions for Longest Substring Without Repeating Characters.
        Memory Usage: 40.4 MB, less than 21.48% of Java online submissions for Longest Substring Without Repeating Characters.
*/

class Solution {
    public int lengthOfLongestSubstring(String s) {
        int left, right, size;
        Window w = new Window();
        left = right = size = 0;
        while (right < s.length()) {
            w.add(s.charAt(right++));
            while (w.check()) {
                w.remove(s.charAt(left++));
            }
            size = Math.max(size, w.size);
        }
        return size;
    }

    class Window {

        int[] map;

        int size, idx;

        public Window() {
            map = new int[130];
        }

        public void add(char c) {
            if (++map[c] == 2) idx = c;
            ++size;
        }

        public void remove(char c) {
            --map[c];
            --size;
        }

        public boolean check() {
            if (map[idx] == 2) return true;
            return false;
        }

        public void disp() {
            for (int i = 'A'; i <= 'z'; i++) {
                System.out.print(map[i] + " ");
            }
            System.out.println();
        }
    }
}
KDLin
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
[享学Hystrix] 九、Hystrix在滑动窗口内统计：BucketedRollingCounterStream、HealthCountsStream
架构师：通透，才能写出好代码！
03-02 1545
上篇文章介绍了桶计数器`BucketedCounterStream`，它提出了桶的概念并且提供了事件到桶的归约操作，可以说为滑动窗口实现打好了基础。 当然，基于`BucketedCounterStream`桶的实现**并不要求必须是滑动窗口**，比如你也可以是固定窗口，也可以是累计计算等。在Hystrix里，基于桶实现的一共有两种统计方式： - 在滑动窗口内统计，子类是`BucketedRollingCounterStream`体系 - 持续累计统计：子类是`BucketedCumulativeCount
滑动窗口的概要介绍与分析
最新发布
05-03
滑动窗口技术的基本思想是通过维护一个固定大小的窗口，在数据流或数据集合上进行滑动操作，从而高效地完成特定的任务。 在滑动窗口算法中，窗口的大小可以根据具体需求进行设定，窗口内的数据可以是连续的序列，也...
滑动窗口问题集合Leetcode
e891377的专栏
05-23 170
滑动窗口问题 3 ，无重复字符的最长子串 76，最小覆盖子串 209，长度最小的子数组 424，替换后的最长重复字符 438，找到字符中所有字母异位词 567，字符串的排列 说明，数字为Leetcode-cn的题号。 比如最小覆盖子串。 ...
Scala中List集合中滑窗的详解
qq_41504585的博客
07-25 948
滑窗的使用详解 在idea中运行 val list1:List[Int] =List(1,2,3,4,5,6,7,8,9,10) println("滑窗") list1.sliding(2, 2).foreach(println) 运行代码如下： list1.sliding(2, 3).foreach(println) 运行代码如下：
有空就来学Hystrix RPC保护的原理，RPC监控之滑动窗口的实现原理
公众号：该用户快成仙了
08-30 242
RPC监控之滑动窗口的实现原理 Hystrix通过滑动窗口的数据结构来统计调用的指标数据，并且大量使用了RxJava响应式编程操作符。滑动窗口的本质就是不断变换的数据流，因此滑动窗口的实现非常适合使用观察者模式以及响应式编程模式去完成。最终，RxJava便成了Hystrix滑动窗口实现的框架选择。Hystrix滑动窗口的核心实现是使用RxJava的window操作符（算子）来完成的。使用RxJava实现滑动窗口还有一大好处就是可以依赖RxJava的线程模型来保证数据写入和聚合的线程安全。 Hystrix
4. 滑动窗口
残梦听雨
12-22 182
import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.util.LinkedList; public class Main { public static void main(String[] args) throws IOException { BufferedReader bf = new BufferedReader(ne
slip_aveimage_滑动窗口_图像滑动平均_
09-29
"slip_aveimage"可能是实现这一功能的程序或脚本，它允许用户自定义滑动窗口的大小和步长，以及处理的图像集合。输出的图像将与原始图像具有相同的坐标系，这意味着处理后的位置关系和比例保持不变，这对于分析和...
滑动窗口算法.zip
04-24
算法是解决特定问题或执行特定任务的一系列步骤或规则的有序集合。在计算机科学中，算法通常用来指导计算机执行特定的任务或解决问题。良好设计的算法能够有效地解决问题，并且在给定的输入下能够产生正确的输出。 ...
jQuery图片滑动特效集合.zip
11-22
《jQuery图片滑动特效集合》 在Web开发领域，jQuery是一种广泛使用的JavaScript库，它极大地简化了DOM操作、事件处理和动画制作等任务。在这个"jQuery图片滑动特效集合"中，我们聚焦于jQuery在创建动态、吸引人的...
论文研究-基于混合差分进化的滑动窗口数据流聚类算法研究.pdf
07-22
针对传统的基于滑动窗口的数据流聚类算法存在的算法执行效率低、聚类质量较差等缺点，提出了一种基于混合差分进化的滑动窗口数据流聚类算法。该算法将数据流聚类过程分为两个部分：在线的时序窗口数据信息微簇特征...
Spring - Hystrix 1.5 滑动窗口实现原理总结
迦南的专栏
03-15 641
总览 Netflix Hystrix 通过类似滑动窗口的数据结构来统计调用的指标数据。Hystrix 1.5 将滑动窗口设计成了数据流（reactive stream, RxJava 中的Observable）的形式。通过消费数据流的形式利用滑动窗口，并对数据流进行变换后进行后续的操作，可以让开发者更加灵活地去使用。由于 Hystrix 里大量使用了 RxJava，再加上滑动窗口本质就是不断变换的数据流，滑动窗口中每个桶的数据都来自于源源不断的事件，因此滑动窗口非常适合用观察者模式和响应式编程思想的 R.
Hystrix浅入浅出：（二）断路器和滑动窗口
大步流星
05-13 314
内容中包含敏感词汇！！！！无法在iteye发布。。。。 请移步：https://blog.csdn.net/manzhizhen/article/details/80296655
Hystrix数据收集及滑动窗口机制解析
Lisam Blog
09-27 1373
依赖如下 <dependency> <groupId>com.netflix.hystrix</groupId> <artifactId>hystrix-core</artifactId> <version>1.5.18</version> </dependency> 什么是Hystrix 2018.11发布了最后一个版本，目前处理维护阶段，不再升级版本 用途： 停止级联故障。
滑动窗口框架
Xurui_Luo的博客
08-20 159
int left = 0, right = 0; while (right < s.size()) { window.add(s[right]); right++; while (valid) { window.remove(s[left]); left++; } } 关键就在于valid条件设计，可能设计到很多的代码
Hystrix
qq_42435514的博客
02-28 287
服务熔断 fallbackMethod="",commandproperties={ @HystrixProperty(name="",value="true"),//是否开启断路器 @HystrixProperty(name="",value="10"),//请求次数 @HystrixProperty(name="",value="10000"),//时间窗口10秒 @HystrixProperty(name="",value="60"),//失败率达到多少后跳闸 } ) ...
hystrix 页面_Hystrix指标窗口实现原理
weixin_32024145的博客
01-14 173
一、引子Hystrix是一个熔断中间件，能够实现fast-fail并走备用方案。Hystrix基于滑动窗口判定服务失败占比选择性熔断。滑动窗口的实现方案有很多种，指标计数也有很多种实现常见的就是AtomicInteger进行原子增减维护计数，具体的方案就不探讨了。Hystrix是基于Rxjava去实现的，那么如何利用RxJava实现指标的汇聚和滑动窗口实现呢？当然本篇不是作为教程去介绍RxJava...
时间窗口（Time Windows)
xiaojia_177
12-08 7081
本贴介绍了时间窗口的相关概念，以及通过举例详细介绍时间窗口的工作原理。 1. 时间窗口 常用的时间窗口有： 翻滚时间窗口(tumbling time window) 滑动时间窗口(sliding time window) 翻滚时间窗口 翻滚时间窗口的窗口固定，比如设定一个1分钟的时间窗口，该时间窗口将只计算当前1分钟内的数据，而不会管前1分钟或后1分钟的数据。 ...
Scala 集合常用函数
m0_72168501的博客
01-07 653
Scala 常用集合函数
sentinel滑动窗口算法
08-24
Sentinel滑动窗口算法是一种用于处理数据流中滑动窗口的算法。它的目标是在一个固定大小的窗口内，对数据流进行实时的处理和分析。 该算法的基本思想是通过维护一个窗口内的数据集合，随着时间的推移，新的数据进入...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值