算法通关村第十六关:白银挑战-滑动窗口经典问题

白银挑战-滑动窗口经典问题

1. 最长子串专题

1.1 无重复字符的最长子串

LeetCode3

思路分析

要找最长子串,需要直到无重复字符串的首和尾,然后再确定最长的那个,需要两个指针,可利用滑动窗口思想

方法1:集合

  • 建立一个集合用于存储无重复的字符
  • 建立滑动窗口的起始位置 left,right
  • right向前滑动
    如果遇到相同元素,left向前滑动并删除集合中对应的元素,直到相同元素被删除,然后再将right对应元素保存至集合中
    如果遇到不同元素,left不变,将right对应元素保存至集合中
  • 一边滑动一边比较集合长度和已知最大长度,最大长度取比较的较大值
  • 字符遍历完成,输出最大长度

方法2:map

  • 定义一个 K-V 形式的map,key表示字符串,value表示其下标索引值
  • 定义两个指针left 和 right,left表示无重复字符串首部索引,right为尾部索引
  • 遍历字符串,每访问一个字符,都将更新map,将字符串下标索引值更新成最新的
    如果遇到重复元素,更新对应下标索引,同时更新left,left取原left值和重复元素索引值+1二者最大值(特殊情况 abba, b先重复,a后重复,防止left倒流)
  • 一边滑动一边比较right-left长度和已知最大长度,最大长度取比较的较大值
  • 字符遍历完成,输出最大长度

代码实现

方法1:集合

class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:
        if not s:
            return 0
        char_set = set()
        left = 0
        max_len = 0
        for right in range(len(s)):
            while s[right] in char_set:
                char_set.remove(s[left])
                left += 1
            char_set.add(s[right])
            max_len = max(max_len, len(char_set))

        return max_len

方法2:map

class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:
        if len(s) == 0:
            return 0
        char_map = {}
        max_len = 0
        left = 0
        for right in range(len(s)):
            if s[right] in char_map:
                left = max(left, char_map[s[right]] + 1)
            char_map[s[right]] = right
            max_len = max(max_len, right - left + 1)
        return max_len

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

LeetCode159 至多包含两个不同字符的最长子串
给你一个字符串 s ,请你找出 至多 包含 两个不同字符 的最长子串,并返回该子串的长度。
https://leetcode.cn/problems/longest-substring-with-at-most-two-distinct-characters/

思路分析

仍然使用 left 和 right 来锁定一个窗口,然后一边向右移动一边分析

我们接下来需要解决两个问题

  1. 怎么判断只有两个元素
  2. 移除时怎么知道移除谁,以及移除之后的left是什么

怎么判断只有两个元素?
还是hash好用,每一个时刻,hashmap包括不超过3个元素

判断移除谁,移除后left是什么?
设计一下hashmap的key-value的含义,key:字符,value:窗口中最右边的字符位置

del_idx = min(hashmap.values())
del hashmap[s[del_idx]]
left = del_idx + 1

代码实现

class Solution:
    def lengthOfLongestSubstringTwoDistinct(self, s: str) -> int:
        if len(s) < 3:
            return len(s)
        char_map = {}
        max_len = 0
        left = 0
        for right in range(len(s)):
            if len(char_map) < 3:
                char_map[s[right]] = right
            if len(char_map) == 3:
                del_idx = min(char_map.values())
                del char_map[s[del_idx]]
                left = del_idx + 1
            max_len = max(max_len, right - left + 1)

        return max_len

1.3 至多包含K个不同字符的最长子串

LeetCode340
https://leetcode.cn/problems/longest-substring-with-at-most-k-distinct-characters/description/

思路分析
与上一题类似,只要把2改为k即可

代码实现

class Solution:
    def lengthOfLongestSubstringKDistinct(self, s: str, k: int) -> int:
        if len(s) < k+1:
            return len(s)
        char_map = {}
        max_len = 0
        left = 0
        for right in range(len(s)):
            if len(char_map) < k+1:
                char_map[s[right]] = right
            if len(char_map) == k+1:
                del_idx = min(char_map.values())
                del char_map[s[del_idx]]
                left = del_idx + 1
            max_len = max(max_len, right - left + 1)

        return max_len

2. 长度最小的子数组

LeetCode209
https://leetcode.cn/problems/minimum-size-subarray-sum/

思路分析

本题可以使用双指针来解决,也可视为队列法

基本思路如下
先让元素不断入队,当入队元素和大于等于target是记录一下此时队列的容量
如果队列元素之和大于等于target则开始出队,直到小于target再入队

代码实现

class Solution:
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        left = 0
        min_len = len(nums) + 1
        total = 0

        for right in range(len(nums)):
            total += nums[right]
            while total >= target:
                min_len = min(min_len, right - left + 1)
                total -= nums[left]
                left += 1
        
        return min_len if min_len <= len(nums) else 0

3. 盛水最多的容器

LeetCode11
https://leetcode.cn/problems/container-with-most-water/

思路分析

盛水的体积的计算:短板的高度*长短板之间的宽度
S(left, right) = min(h[left], h[right])(right - left)

长短板分列最左边和最右边,宽度最大,此时长板或短板向中间收窄,宽度会变小,此时板的高度

  • 若短板向中间收窄,短板可能变大,水槽面积可能增加
  • 若长板向中间收窄,短板可能变小或不变,水槽面积一定变小

具体执行

  • 初始双指针分列水槽的左右两端
  • 循环每轮将短板向内移动一格
  • 更新面积的最大值,直到两指针相遇时跳出,即可获得最大面积

代码实现

class Solution:
    def maxArea(self, height: List[int]) -> int:
        left, right = 0, len(height)-1
        s = 0
        while left < right:
            s = max(s, min(height[left], height[right]) * (right - left))
            if height[left] < height[right]:
                left += 1
            else:
                right -= 1
        return s

4. 寻找子串异位词(排列)

异位词(排列)
如果两个字符串仅仅是字母出现的位置不一样,则称两者互为对方的一个排列,也称异位词

如何判断?

  • 字母的类型一样
  • 每个字母出现的个数也是一样的

4.1 字符串的排列

LeetCode 567
https://leetcode.cn/problems/permutation-in-string/

思路分析

  • 字符串的异位词长度 和 字符串的长度是样的,所以以字符串的长度作为滑动窗口的大小
  • 窗口一边右移,一边比较
  • 如何判断异位词,排序的代价太高了,可以创建一个大小为26的数组,每个位置存储从a到z的个数
    数组索引使用 index = s1.charAt(i) - ‘a’ 来表示
  • 窗口右移:charArray[s2.charAt(right) - ‘a’]++
  • 窗口左移:int left = right - s1.length; charArray[s2.charAt(left) - ‘a’]–

代码实现

python中字母与ascii转换 chr() ord()

class Solution:
    def checkInclusion(self, s1: str, s2: str) -> bool:
        n1, n2 = len(s1), len(s2)
        if n1 > n2:
            return False
        char_arr1 = [0] * 26
        char_arr2 = [0] * 26
        for i in range(n1):
            char_arr1[ord(s1[i]) - ord('a')] += 1
            char_arr2[ord(s2[i]) - ord('a')] += 1

        if char_arr1 == char_arr2:
            return True

        left = 0
        for right in range(n1, n2):
            char_arr2[ord(s2[right]) - ord('a')] += 1
            char_arr2[ord(s2[left]) - ord('a')] -= 1
            left += 1
            if char_arr1 == char_arr2:
                return True

        return False

4.2 找到字符串中所有字母异位

LeetCode438
https://leetcode.cn/problems/find-all-anagrams-in-a-string/

思路分析
思路分析同上题一致,多加了一步进行处理

增加了一个列表,记录出现异位词的位置,如果出现了,将其加到列表中

代码实现

class Solution:
    def findAnagrams(self, s: str, p: str) -> List[int]:
        n1, n2 = len(p), len(s)
        if n1 > n2:
            return []
        res = []
        char_arr1 = [0] * 26
        char_arr2 = [0] * 26
        for i in range(n1):
            char_arr1[ord(p[i]) - ord('a')] += 1
            char_arr2[ord(s[i]) - ord('a')] += 1

        if char_arr1 == char_arr2:
            res.append(0)

        left = 0
        for right in range(n1, n2):
            char_arr2[ord(s[right]) - ord('a')] += 1
            char_arr2[ord(s[left]) - ord('a')] -= 1
            left += 1
            if char_arr1 == char_arr2:
                res.append(left)

        return res
class Solution:
    def findAnagrams(self, s: str, p: str) -> List[int]:
        p_len, s_len = len(p), len(s)
        if p_len > s_len:
            return []
        res = []
        p_count = [0] * 26
        s_count = [0] * 26
        for i in range(p_len):
            p_count[ord(p[i]) - ord('a')] += 1
            s_count[ord(s[i]) - ord('a')] += 1

        if p_count == s_count:
            res.append(0)

        for i in range(s_len - p_len):
            s_count[ord(s[i + p_len]) - ord('a')] += 1
            s_count[ord(s[i]) - ord('a')] -= 1
            if p_count == s_count:
                res.append(i + 1)

        return res

你可能感兴趣的:(算法,python,java)