滑动窗口

3. 无重复字符的最长子串

难度中等3334收藏分享切换为英文关注反馈

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

示例 1:

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

示例 2:

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

示例 3:

输入: "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
     请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。

class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:
        if not s:
            return 0

        s_len = len(s)
        lookup = set()
        longest_len = 0
        right_point = -1

        for left_point in range(s_len):
            if left_point != 0:
                lookup.discard(s[left_point-1])
            while right_point+1<s_len and s[right_point+1] not in lookup:
                lookup.add(s[right_point+1])
                right_point += 1

            longest_len = max(longest_len, right_point-left_point+1)

        return longest_len

#
# 
# @param arr int整型一维数组 the array
# @return int整型
#
class Solution:
    def maxLength(self , s):
        if not s:
            return 0
#         return 1

        lookup = list()
        s_length = len(s)
        length_LongestSubstring = 0
        current_max_length = 0

        for right in range(s_length):
            val = s[right]
            if not val in lookup:
                lookup.extend([val])
                current_max_length += 1
            else:
                left = lookup.index(val)
                lookup = lookup[left+1: ]
                lookup.extend([val])
                current_max_length = len(lookup)

            if current_max_length > length_LongestSubstring:
                length_LongestSubstring = current_max_length

        return length_LongestSubstring
    

while True:
    try:
        import sys
        lines=sys.stdin.readline()
        arr = list(map(int,lines.split(']')[0].split('[')[-1].split(',')))
        S = Solution()
        res = S.maxLength(arr)
        print(res)
    except:
        break

424. 替换后的最长重复字符

难度中等81收藏分享切换为英文关注反馈

给你一个仅由大写英文字母组成的字符串，你可以将任意位置上的字符替换成另外的字符，总共可最多替换 k 次。在执行上述操作后，找到包含重复字母的最长子串的长度。

注意:
字符串长度 和 k 不会超过 104。

示例 1:

输入:
s = "ABAB", k = 2

输出:
4

解释:
用两个'A'替换为两个'B',反之亦然。

示例 2:

输入:
s = "AABABBA", k = 1

输出:
4

解释:
将中间的一个'A'替换为'B',字符串变为 "AABBBBA"。
子串 "BBBB" 有最长重复字母, 答案为 4。

class Solution:
    def characterReplacement(self, s: str, k: int) -> int:
        if not s:
            return 0

        chars_frequences = [0 for _ in range(26)]
        left = 0
        right = 0
        char_max_frequence = 0
        max_substring_len = 0

        while right < len(s):
            chars_frequences[ord(s[right])-ord('A')] += 1 
            char_max_frequence = max(chars_frequences)

            if  char_max_frequence + k >= right - left+1:          
                right += 1  
                max_substring_len = max(max_substring_len, right-left)  
            else:
                chars_frequences[ord(s[left])-ord('A')] -= 1
                left += 1
                right += 1
                
        return max_substring_len

124. 最长连续序列

中文English

给定一个未排序的整数数组，找出最长连续序列的长度。

Example

样例 1

输入 : [100, 4, 200, 1, 3, 2]
输出 : 4
解释 : 这个最长的连续序列是 [1, 2, 3, 4]. 返回所求长度 4

Clarification

要求你的算法复杂度为O(n)

class Solution:
    """
    @param num: A list of integers
    @return: An integer
    """
    def longestConsecutive(self, num):
        # write your code here
        ans = 1
        uniq_num_visted = {n: False for n in num}
        
        for n in uniq_num_visted:
            if uniq_num_visted[n]:
                continue
            
            uniq_num_visted[n] = True
            
            while n + 1 in uniq_num_visted:
                uniq_num_visted[n + 1] = True
                n += 1
            high = n

            while n - 1 in uniq_num_visted:
                uniq_num_visted[n - 1] = True
                n -= 1
            low = n
            
            ans = max(ans, high-low+1)

 
        return ans

 

#
# max increasing subsequence
# @param arr int整型一维数组 the array
# @return int整型
#
class Solution:
    def MLS(self , arr ):
        # write code here
        if not arr:
            return 0
        arr_set = set(arr)
        res = 0
        
        for key in arr_set:
            if key - 1 in arr_set:
                continue
            high = key
            while high + 1 in arr_set:
                high = high + 1
            res = max(res, high-key+1)
            
        return res

567. 字符串的排列

难度中等101收藏分享切换为英文关注反馈

给定两个字符串 s1 和 s2，写一个函数来判断 s2 是否包含 s1 的排列。

换句话说，第一个字符串的排列之一是第二个字符串的子串。

示例1:

输入: s1 = "ab" s2 = "eidbaooo"
输出: True
解释: s2 包含 s1 的排列之一 ("ba").

示例2:

输入: s1= "ab" s2 = "eidboaoo"
输出: False

注意：

1. 输入的字符串只包含小写字母
2. 两个字符串的长度都在 [1, 10,000] 之间

class Solution:
    def checkInclusion(self, s1: str, s2: str) -> bool:
        if len(s1) > len(s2): 
            return False
        if not s1:
            return True

        s1_len = len(s1)
        s2_len = len(s2)
        windows = {}
        needs = {}

        for s1_item in s1:
            needs[s1_item] = needs.setdefault(s1_item, 0) + 1
    
        for index in range(s1_len-1):
            windows[s2[index]] = windows.setdefault(s2[index], 0) + 1
        
        for index in range(s1_len-1, s2_len):
            windows[s2[index]] = windows.setdefault(s2[index], 0) + 1
            if needs == windows:
                return True
            else:
                windows[s2[index-s1_len+1]] -= 1
                if windows[s2[index-s1_len+1]] == 0:
                    windows.pop(s2[index-s1_len+1])

        return False