LeetCode第11天（三） huawei 测试题 滑动窗口

以下题目来源力扣

209. 长度最小的子数组
给定一个含有 n 个正整数的数组和一个正整数 target 。

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

class Solution:
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        start=0
        end=0
        min_=100001
        sum_=0
        while end<len(nums):
            
            sum_=sum_+nums[end]
            while sum_>=target:
                min_=min(min_,end-start+1)
                sum_=sum_-nums[start]
                start=start+1
            end=end+1
                
        if min_==100001:
            return 0
        return min_

时间复杂度：O(n)，其中 n 是数组的长度。指针 start 和 end 最多各移动 n 次。
空间复杂度：O(1)。

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

class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:
        start=0
        end=0
        max_=0
        n=len(s)
        temp=[]
        while end<n:
            while s[end] in temp:
                max_=max(max_,end-start) 
                temp.pop(0)
                start=start+1
            temp.append(s[end])
            end=end+1
        return max(max_,end-start)

1004. 最大连续1的个数 III
给定一个二进制数组 nums 和一个整数 k，如果可以翻转最多 k 个 0 ，则返回 数组中连续 1 的最大个数 。

class Solution:
    def longestOnes(self, nums: List[int], k: int) -> int:
        start=0
        end=0
        max_=0
        n=len(nums)
        count=0
        while end<n:
            if nums[end]==0:
                count=count+1
            while count>k:
                max_=max(max_,end-start)
                # print(max_)
                if nums[start]==0:
                    count=count-1
                start=start+1

            end=end+1
        return max(max_,end-start)

1208. 尽可能使字符串相等
给你两个长度相同的字符串，s 和 t。

将 s 中的第 i 个字符变到 t 中的第 i 个字符需要 |s[i] - t[i]| 的开销（开销可能为 0），也就是两个字符的 ASCII 码值的差的绝对值。

用于变更字符串的最大预算是 maxCost。在转化字符串时，总开销应当小于等于该预算，这也意味着字符串的转化可能是不完全的。

如果你可以将 s 的子字符串转化为它在 t 中对应的子字符串，则返回可以转化的最大长度。

如果 s 中没有子字符串可以转化成 t 中对应的子字符串，则返回 0。

class Solution:
    def equalSubstring(self, s: str, t: str, maxCost: int) -> int:
        start=0
        end=0
        n=len(s)
        max_=0
        cost=0
        while end<n:
            cost=cost+abs(ord(t[end])-ord(s[end]))
            while cost>maxCost:
                max_=max(max_,end-start)
                cost=cost-abs(ord(t[start])-ord(s[start]))
                start=start+1
            end=end+1
        return max(max_,end-start)