python代码练习:滑动窗口

前置:

  • 什么是滑动窗口
  • -inf 与 inf 用法
  • 理解滑动窗口主要弄清以下问题:
    • 1、窗口内的数据代表着什么?
    • 2、什么情况下需要扩展窗口右边界?
    • 3、什么情况下需要收缩窗口左边界?
    • 4、什么时候计算窗口大小?

题目1:长度最小的子数组

给定一个含有 n 个正整数的数组和一个正整数 target 。

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

from typing import List
class Solution:
    def minSubArrayLen(self, s: int, nums: List[int]) -> int:
            sum=0
            i=0
            temp = float('inf')
            for j in range(len(nums)):  # 遍历数组种每一个item,并累加
               sum+=nums[j]
               
               while sum>=s:    # 满足目标条件后,开始缩小窗口
                   L = j-i+1    
                   temp = min(temp,L)   
                   # 目标是计算sum>=s时的最小窗口程度,该目标与while条件一直,所以写在while里面
                   # 并在窗口左边界变化之前就计算窗口大小
                   sum-=nums[i]
                   i+=1
            if temp==float('inf') :return  0
            else:return temp

s=Solution()
print(s.minSubArrayLen(s=7,nums=[2,3,1,2,4,3]))
print(s.minSubArrayLen(s=4,nums=[1,4,4]))
print(s.minSubArrayLen(s=11,nums=[1,1,1,1]))

题目2:水果成篮

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

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

  • 你只有 两个 篮子,并且每个篮子只能装 单一类型 的水果。每个篮子能够装的水果总量没有限制。
  • 你可以选择任意一棵树开始采摘,你必须从 每棵 树(包括开始采摘的树)上 恰好摘一个水果 。采摘的水果应当符合篮子中的水果类型。每采摘一次,你将会向右移动到下一棵树,并继续采摘。
  • 一旦你走到某棵树前,但水果不符合篮子的水果类型,那么就必须停止采摘。

给你一个整数数组 fruits ,返回你可以收集的水果的 最大 数目。

from collections import defaultdict
from typing import List
class Solution:
    def totalFruit(self, fruits: List[int]) -> int:
        a,i=len(fruits),0
        tree=0
        temp=0
        dic_tree = defaultdict(int)
        for j in range(a):  # 从左到右遍历每一个item,对每个item计数并将数据放入字典
            dic_tree[fruits[j]]+=1
            if dic_tree[fruits[j]] == 1:
                tree+=1 # 树的数量+到1时,意味着有新类型的树增加

            while tree>2:   # 树的类型超过2种时,开始缩小窗口
                dic_tree[fruits[i]]-=1
                if dic_tree[fruits[i]]==0:
                    tree-=1
                i+=1
            temp=max(temp,j-i+1)
            # 目标是计算tree<=2时窗口的大小,该目标与上文while条件不一致,所以写在while之外
        return temp

s=Solution()
print(s.totalFruit(fruits=[0,1,2,1]))
print(s.totalFruit(fruits=[1,2,1]))

题目3:无重复字符的最长子串

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

例1:s='ababaa'  最长子串是 ab ,长度为2

例2:s='cccccc'  最长子串是 c ,长度为1

例1:s='dvdf'  最长子串是 vdf ,长度为3

class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:
        temp_s=set()
        j=-1
        temp=0
        # 遍历窗口左边界
        for i in range(len(s)):
            #窗口右边界 in set,就会跳出while循环,从for开始继续遍历左边界(收缩窗口左边界)
            if i!=0:
                temp_s.remove(s[i-1])
            # 遍历窗口右边界
            # 窗口右边界一旦 not in set,就继续扩展右边界
            while j + 1 < len(s) and s[j + 1] not in temp_s:
                temp_s.add(s[j+1])
                j+=1
            temp = max(temp,j-i+1)
        return temp

s=Solution()
print(s.lengthOfLongestSubstring(s='dvdf'))

题目4:找到字符串中所有字母异位词

给定两个字符串 s 和 p,找到 s 中所有 p 的 异位词 的子串,返回这些子串的起始索引。不考虑答案输出的顺序。

异位词 指由相同字母重排列形成的字符串(包括相同的字符串)。

# 以p_len长度的数据作为窗口
# 窗口内字符计数 == p串的字符计数 时,满足题目要求,返回窗口左边界
class Solution:
    def findAnagrams(self, s: str, p: str) -> List[int]:
        res = []
        s_len,p_len  = len(s),len(p)
        s_count=[0]*26
        p_count=[0]*26

        for i  in range(p_len):    # p_len长度时,初始窗口字符计数、p串字符计数
            s_count[ord(s[i])-97]+=1
            p_count[ord(p[i])-97]+=1

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

        for i in range(s_len - p_len):    # 窗口右移
            s_count[ord(s[i])-97]-=1    # 左边界变化,旧字符计数-1
            s_count[ord(s[i+p_len])-97]+=1    # 右边界变化,新字符计数+1
            if s_count==p_count:
                res.append(i+1)    

        return res

题目5:串联所有单词的子串( 滑动窗口结合哈希表 )

给定一个字符串 s 和一个字符串数组 words words 中所有字符串 长度相同

 s 中的 串联子串 是指一个包含  words 中所有字符串以任意顺序排列连接起来的子串。

  • 例如,如果 words = ["ab","cd","ef"], 那么 "abcdef", "abefcd""cdabef", "cdefab""efabcd", 和 "efcdab" 都是串联子串。 "acdbef" 不是串联子串,因为他不是任何 words 排列的连接。

返回所有串联子串在 s 中的开始索引。你可以以 任意顺序 返回答案。

# 窗口内数据:words元素的组合
# 窗口总长度:words元素个数m * 单个元素长度n = total_l
##### words单词计数 == 窗口单词计数 时,满足题目要求
# 如何从s获取窗口:对s切片,即s[i:i+total_l]
# 如何从窗口中切分出单词:通过步长确定单词长度(0,total_l,n),对窗口切片w[j:j+n]

from typing import List
from collections import Counter

class Solution:
    def findSubstring(self, s: str, words: List[str]) -> List[int]:
        res = []
        m, n, ls = len(words), len(words[0]), len(s)
        total_l = m*n   # 窗口总长度
        cnt = Counter(words)    # 对words单词计数
        for i in range(ls-n+1): 
            w = s[i:i+total_l]  # 切片,切出一个窗口
            tmp = []
            for j in range(0,total_l,n):    # 按步长(单词长度)切分窗口,获取窗口内的单词
                tmp.append(w[j:j+n])
            if Counter(tmp) == cnt: # 窗口单词计数 == wordes单词计数时,返回窗口左边界i
                res.append(i)
        return res
if __name__ == '__main__':
    s=Solution()
    print(s.findSubstring(s='barfoothefoobarman',words=["foo","bar"]))

其他:

Count() 用法

你可能感兴趣的:(Python,python)