数组——滑动窗口

UpUpUp7

已于 2023-05-28 20:07:58 修改

阅读量103

点赞数 1

文章标签： leetcode 算法 python java javascript

于 2023-05-25 11:15:09 首次发布

本文链接：https://blog.csdn.net/ccnever/article/details/130859304

版权

滑动窗口

参考链接

1.理论

所谓滑动窗口，本质上是利用快慢指针，其中慢指针指向窗口的起始位置，快指针指向窗口的终止位置，这会让我得到一个符合条件的结果。不断重复这个过程，便会得到最终结果。

那么，什么是窗口呢？
简单来说，就是符合条件的连续序列。

因为整个过程像是一个窗口的移动，所以称为滑动窗口！

2.实践

209. 长度最小的子数组

力扣链接
给定一个含有 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 <= target <= $10^9$
1 <= nums.length <= $10^5$
1 <= nums[i] <= $10^5$

Java代码如下：

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int leftIndex = 0,
            sum = 0,
            ans = Integer.MAX_VALUE;
        for(int rightIndex = 0; rightIndex < nums.length; rightIndex++) {
            sum += nums[rightIndex];
            while(sum >= target) {
                ans = Math.min(rightIndex - leftIndex + 1, ans);
                sum -= nums[leftIndex++];   // 滑动窗口的精髓之处，不断变更leftIndex（子序列的起始位置）
            }
        }
        return ans == Integer.MAX_VALUE ? 0 : ans;
    }
}

JavaScript代码如下：

/**
 * @param {number} target
 * @param {number[]} nums
 * @return {number}
 */
var minSubArrayLen = function(target, nums) {
    let leftIndex = 0,
        sum =  0,
        ans =  Infinity
    for(let rightIndex = 0; rightIndex < nums.length; rightIndex++) {
        sum += nums[rightIndex]
        while(sum >= target) {
            ans = Math.min(rightIndex - leftIndex + 1, ans)
            sum -= nums[leftIndex++]
        }
    }
    return ans == Infinity ? 0 : ans
};

Python代码如下：

class Solution:
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        leftIndex, rightIndex, sums, ans = 0, 0, 0, float('inf')
        while rightIndex < len(nums):
            sums += nums[rightIndex]
            while sums >= target:
                ans = min(rightIndex - leftIndex + 1, ans)
                sums -= nums[leftIndex]
                leftIndex += 1
            rightIndex += 1
        return ans if ans != float('inf') else 0

904. 水果成篮

力扣链接
你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组 fruits 表示，其中 fruits[i] 是第 i 棵树上的水果种类。

你想要尽可能多地收集水果。然而，农场的主人设定了一些严格的规矩，你必须按照要求采摘水果：

你只有两个篮子，并且每个篮子只能装单一类型的水果。每个篮子能够装的水果总量没有限制。
你可以选择任意一棵树开始采摘，你必须从每棵树（包括开始采摘的树）上恰好摘一个水果。采摘的水果应当符合篮子中的水果类型。每采摘一次，你将会向右移动到下一棵树，并继续采摘。
一旦你走到某棵树前，但水果不符合篮子的水果类型，那么就必须停止采摘。
给你一个整数数组 fruits ，返回你可以收集的水果的最大数目。

转换一下上述题目：求一个序列中至多包含2个不同数字的最长子序列。

示例1：

	输入：fruits = [1,2,1]
	输出：3
	解释：可以采摘全部 3 棵树。

示例2：

	输入：fruits = [0,1,2,2]
	输出：3
	解释：可以采摘 [1,2,2] 这三棵树。
	如果从第一棵树开始采摘，则只能采摘 [0,1] 这两棵树。

示例3：

	输入：fruits = [1,2,3,2,2]
	输出：4
	解释：可以采摘 [2,3,2,2] 这四棵树。
	如果从第一棵树开始采摘，则只能采摘 [1,2] 这两棵树。

示例4：

	输入：fruits = [3,3,3,1,2,1,1,2,3,3,4]
	输出：5
	解释：可以采摘 [1,2,1,1,2] 这五棵树。

提示：

1 <= fruits.length <= $10^5$
0 <= fruits[i] <= fruits.length

Java代码如下：

class Solution {
    public int totalFruit(int[] fruits) {
        int leftIndex = 0,
                ans = Integer.MIN_VALUE;
        HashMap<Integer, Integer> typeMap = new HashMap<>(16);
        for (int rightIndex = 0; rightIndex < fruits.length; rightIndex++) {
            typeMap.put(fruits[rightIndex], typeMap.getOrDefault(fruits[rightIndex], 0) + 1);
            while (typeMap.size() > 2) {
                typeMap.put(fruits[leftIndex], typeMap.get(fruits[leftIndex]) - 1);
                if (typeMap.get(fruits[leftIndex]) == 0) {
                    typeMap.remove(fruits[leftIndex]);
                }
                leftIndex++;
            }
            ans = Math.max(rightIndex - leftIndex + 1, ans);
        }
        return ans;
    }
}

JavaScript代码如下：

/**
 * @param {number[]} fruits
 * @return {number}
 */
var totalFruit = function(fruits) {
    let leftIndex = 0,
        typeMap = new Map()
        ans = -Infinity;
    for (let rightIndex = 0; rightIndex < fruits.length; rightIndex++) {
        typeMap.set(fruits[rightIndex], (typeMap.get(fruits[rightIndex]) || 0) + 1)
        while (typeMap.size > 2) {
            typeMap.set(fruits[leftIndex], typeMap.get(fruits[leftIndex]) - 1)
            if (typeMap.get(fruits[leftIndex]) == 0) {
                typeMap.delete(fruits[leftIndex])
            }
            leftIndex++;
        }
        ans = Math.max(rightIndex - leftIndex + 1, ans)
    }
    return ans
};

Python代码如下：

class Solution:
    def totalFruit(self, fruits: List[int]) -> int:
        leftIndex, rightIndex, typeMap, ans = 0, 0, {}, float('-inf')
        while rightIndex < len(fruits):
            typeMap[fruits[rightIndex]] = typeMap.get(fruits[rightIndex], 0) + 1
            while len(typeMap) > 2:
                typeMap[fruits[leftIndex]] = typeMap.get(fruits[leftIndex]) - 1
                if typeMap.get(fruits[leftIndex]) == 0:
                    typeMap.pop(fruits[leftIndex])
                leftIndex += 1
            ans = max(rightIndex - leftIndex + 1, ans)
            rightIndex += 1
        return ans

76. 最小覆盖子串

力扣链接
给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串，则返回空字符串 “” 。

注意：

对于 t 中重复字符，我们寻找的子字符串中该字符数量必须不少于 t 中该字符数量。
如果 s 中存在这样的子串，我们保证它是唯一的答案。

示例1：

	输入：s = "ADOBECODEBANC", t = "ABC"
	输出："BANC"
	解释：最小覆盖子串 "BANC" 包含来自字符串 t 的 'A'、'B' 和 'C'。

示例2：

	输入：s = "a", t = "a"
	输出："a"
	解释：整个字符串 s 是最小覆盖子串。

示例3：

	输入: s = "a", t = "aa"
	输出: ""
	解释: t 中两个字符 'a' 均应包含在 s 的子串中，
	因此没有符合条件的子字符串，返回空字符串。

Java代码如下：

class Solution {
    HashMap<Character, Integer> charCount = new HashMap<>();
    /**
     * 创建哈希表hashCount，用于统计在遍历字符串s的过程中，s中各个出现字符的个数
     */
    HashMap<Character, Integer> hashCount = new HashMap<>();

    public String minWindow(String s, String t) {
        int leftIndex = 0, rightIndex = 0;
        String ans = "";

        /**统计字符串t中的字符*/
        for (char c : t.toCharArray()) {
            charCount.put(c, charCount.getOrDefault(c, 0) + 1);
        }
        /**遍历字符串s，找到最小符合条件的最小子串*/
        while (rightIndex < s.length()) {
            char c = s.charAt(rightIndex);
            if (charCount.containsKey(c)) {
                hashCount.put(c, hashCount.getOrDefault(c, 0) + 1);
            }
            while (checkCount() && leftIndex <= rightIndex) {
                if (ans.equals("") || (!ans.equals("") && ans.length() > (rightIndex - leftIndex + 1))) {
                    ans = s.substring(leftIndex, rightIndex + 1);
                }
                char c1 = s.charAt(leftIndex);
                if (hashCount.containsKey(c1)) {
                    hashCount.put(c1, hashCount.get(c1) - 1);
                }
                leftIndex++;
            }
            rightIndex++;
        }
        return ans;
    }

    /**
     * 检查两个字典是否匹配
     */
    public boolean checkCount() {
        Set<Character> keySet = charCount.keySet();
        for (Character key : keySet) {
            if (charCount.get(key) > hashCount.getOrDefault(key, 0)) {
                return false;
            }
        }
        return true;
    }
}

JavaScript代码如下：

/**
 * @param {string} s
 * @param {string} t
 * @return {string}
 */
let charMap = new Map(),
    hashMap = new Map();
var minWindow = function (s, t) {
    /**这里是专门针对JS做的修改，因为代码在执行的时候完全正确，但是提交却出现了用例2报错，经过测试，发现是map中存在了别的键值对，因此，采取清空 */
    charMap.clear();
    hashMap.clear();
    let leftIndex = 0,
        rightIndex = 0,
        ans = "";
    for (let i = 0; i < t.length; i++) {
        charMap.set(t[i], (charMap.get(t[i]) || 0) + 1);
    }
    while (rightIndex < s.length) {
        if (charMap.has(s[rightIndex])) {
            hashMap.set(s[rightIndex], (hashMap.get(s[rightIndex]) || 0) + 1);
        }
        while (checkCount() && leftIndex <= rightIndex) {
            if (ans == "" || (ans != "" && ans.length > rightIndex - leftIndex + 1)) {
                ans = s.slice(leftIndex, rightIndex + 1);
            }
            if (hashMap.has(s[leftIndex])) {
                hashMap.set(s[leftIndex], hashMap.get(s[leftIndex]) - 1);
            }
            leftIndex++;
        }
        rightIndex++;
    }
    return ans;
};
let checkCount = function (s, t) {
    for (const [key, value] of charMap) {
        if ((hashMap.get(key) || 0) < value) {
            return false;
        }
    }
    return true;
}

Python代码如下：

class Solution:
    def minWindow(self, s: str, t: str) -> str:
        charMap, hashMap = {}, {}
        leftIndex, rightIndex, ans = 0, 0, ""
        for c in set(t):
            charMap[c] = t.count(c)
        for c in s:
            if c in t:
                hashMap[c] = hashMap.get(c, 0) + 1
            while self.checkCount(charMap, hashMap) and leftIndex <= rightIndex:
                if ans == "" or ans != "" and len(ans) > rightIndex - leftIndex + 1:
                    ans = s[leftIndex: rightIndex + 1]
                if s[leftIndex] in hashMap:
                    hashMap[s[leftIndex]] = hashMap.get(s[leftIndex]) - 1
                leftIndex += 1
            rightIndex += 1
        return ans    
        

    def checkCount(self, charMap: dict, hashMap: dict) -> bool:
        for key in charMap:
            if charMap.get(key) > hashMap.get(key, 0):
                return False
        return True