【算法】滑动窗口

在算法中,滑动窗口是一种处理连续子数组或子字符串的技术。它通过定义一个固定大小的窗口,使用两个指针,在数组或字符串上移动这个窗口,以便对窗口内的数据进行操作或计算。

一、Leetcode3.无重复字符的最长子串

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

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

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

示例 3:
输入: s = "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke",所以其长度为 3。
     请注意,你的答案必须是 子串 的长度,"pwke" 是一个子序列,不是子串。
1.暴力破解

两个for循环把所有子串存入集合,最后找出所有子串中最大值。

class Solution {
    public int lengthOfLongestSubstring(String s) {
        if(s.length()==0){
            return 0;
        }
        char ss[] = s.toCharArray();
        List<String> list = new ArrayList();
        Set<String> set = new HashSet();
        List<Integer> subList = new ArrayList();
        
        for (int i = 0; i < ss.length; i++) {
            outer:
            for(int j = i;j<ss.length;j++){
                list.add(String.valueOf(ss[j]));
                set.add(String.valueOf(ss[j]));
                if(list.size()>set.size()){
                    subList.add(list.size()-1);
                    list.clear();
                    set.clear();
                    break outer;
                }
            }
        }
        if(subList.size()==0){
            return 1;
        }
        
        int max = subList.get(0);
        for(int k = 0;k<subList.size();k++){
            int cur = subList.get(k);
            if(max<cur){
                max = cur;
            }
        }
        return max;
    }
}
2.滑动窗口
  • 存储窗口元素的集合(元素不可重复):Set
  • 两个指针 :left左指针 right右指针

左右指针同时从下标0开始,右指针一直往右移动,每次移动到的元素存入窗口元素集合,记录当前长度和最大长度,如果当前长度比最大长度大,则更新最大长度;当遇到当前元素与窗口集合中的元素相同时,移动左指针,同时更新窗口的元素集合(窗口存储的是左右指针之间的元素),直到右指针的元素可以放入窗口集合则左指针停下来,继续移动右指针;如此反复,直到右指针遍历完所有元素,移动过程中记录的最大长度就是最长子串。
最长子串.jpeg

class Solution {
    public int lengthOfLongestSubstring(String s) {
        char[] chars = s.toCharArray();
        Set<Character> set = new HashSet<>();
        int maxLength = 0;
        int left = 0;
        // 右指针前进
        for (int right = 0; right < chars.length; right++) {
            if(set.add(chars[right])){
                int length = right - left + 1;
                if(length > maxLength){
                    maxLength = length;
                }
            }else{
                while (!set.add(chars[right])){
                    //移除窗口元素
                    set.remove(chars[left]);
                    //左指针前进
                    left++;
                }
            }
        }
        return maxLength;
    }
}

二、Leetcode209.长度最小的子数组

给定一个含有 n 个正整数的数组和一个正整数 target 。
找出该数组中满足其总和大于等于 target 的长度最小的连续子数组[numsl, numsl+1, ..., numsr-1, numsr],并返回其长度。如果不存在符合条件的子数组,返回 0 。

示例 1:
输入:target = 7, nums = [2,3,1,2,4,3]
输出:2
解释:子数组 [4,3] 是该条件下的长度最小的子数组。

示例 2:
输入:target = 4, nums = [1,4,4]
输出:1

示例 3:
输入:target = 11, nums = [1,1,1,1,1,1,1,1]
输出:0
1.暴力破解
  public int minSubArrayLen1(int target, int[] nums) {
        int result = Integer.MAX_VALUE;
        for (int i = 0; i < nums.length; i++) {
            int sum = 0;
            for (int j = i; j < nums.length; j++) {
                sum = sum + nums[j];
                if (sum >= target) {
                    int length = j - i + 1;
                    if (result > length) {
                        result = length;
                    }
                }
            }
        }
        return result == Integer.MAX_VALUE ? 0 : result;
    }

此种解法力扣通不过

2.前缀和+二分

这种解法是暴力的优化,在第二层for循环中 ,不是一个个的找,而是使用二分来提高查找效率,从而降低时间复杂度

  public int minSubArrayLen2(int target, int[] nums) {
        // 前缀和数组
        int[] sums = new int[nums.length+1];
        sums[0] = 0;
        for (int i = 1; i <= nums.length; i++) {
            sums[i] = sums[i - 1] + nums[i-1];
        }

        int result = Integer.MAX_VALUE;
        for (int k = 0; k < sums.length; k++) {
            // 二分查找
            int i = k;
            int j = sums.length - 1;
            while (i <= j) {
                int mid = (i + j) >>> 1;
                if (sums[mid] - sums[k] >= target) {
                    j = mid - 1;
                    if((mid-k) < result){
                        result = mid-k;
                    }
                } else {
                    i = mid + 1;
                }
            }
        }
        return result == Integer.MAX_VALUE ? 0 : result;
    }
3.滑动窗口

思路:使用两个指针,左指针和右指针来固定窗口,右指针一直前进,当前进到窗口中的元素总和大于等于了目标target的时候,右指针停下来,移动左指针,看是否还有更小长度的能满足目标。不满足的时候,右指针继续前进,如此反复,找到一个最小长度的窗口元素。

    public int minSubArrayLen(int target, int[] nums) {
        int left = 0;
        int minLength = Integer.MAX_VALUE;
        int sum = 0;
        // 右指针right前进
        for (int right = 0; right < nums.length; right++) {
            sum = sum + nums[right];
            while (sum >= target) {
                int length = right - left + 1;
                if (length < minLength) {
                    minLength = length;
                }
                //更新sum
                sum = sum - nums[left];
                //缩小窗口 左指针前进
                left++;
            }
        }
        return minLength == Integer.MAX_VALUE ? 0 : minLength;
    }
  • 5
    点赞
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值