滑动窗口

滑动窗口

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

难度中等

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

示例 1:

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

示例 2:

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

示例 3:

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

 1 class Solution:
 2     def lengthOfLongestSubstring(self, s: str) -> int:
 3         if not s:
 4             return 0
 5 
 6         s_len = len(s)
 7         lookup = set()
 8         longest_len = 0
 9         right_point = -1
10 
11         for left_point in range(s_len):
12             if left_point != 0:
13                 lookup.discard(s[left_point-1])
14             while right_point+1<s_len and s[right_point+1] not in lookup:
15                 lookup.add(s[right_point+1])
16                 right_point += 1
17 
18             longest_len = max(longest_len, right_point-left_point+1)
19 
20         return longest_len

View Code

 1 #
 2 # 
 3 # @param arr int整型一维数组 the array
 4 # @return int整型
 5 #
 6 class Solution:
 7     def maxLength(self , s):
 8         if not s:
 9             return 0
10 #         return 1
11 
12         lookup = list()
13         s_length = len(s)
14         length_LongestSubstring = 0
15         current_max_length = 0
16 
17         for right in range(s_length):
18             val = s[right]
19             if not val in lookup:
20                 lookup.extend([val])
21                 current_max_length += 1
22             else:
23                 left = lookup.index(val)
24                 lookup = lookup[left+1: ]
25                 lookup.extend([val])
26                 current_max_length = len(lookup)
27 
28             if current_max_length > length_LongestSubstring:
29                 length_LongestSubstring = current_max_length
30 
31         return length_LongestSubstring
32     
33 
34 while True:
35     try:
36         import sys
37         lines=sys.stdin.readline()
38         arr = list(map(int,lines.split(']')[0].split('[')[-1].split(',')))
39         S = Solution()
40         res = S.maxLength(arr)
41         print(res)
42     except:
43         break

View Code

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

难度中等

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

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

示例 1:

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

输出:
4

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

示例 2:

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

输出:
4

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

 1 class Solution:
 2     def characterReplacement(self, s: str, k: int) -> int:
 3         if not s:
 4             return 0
 5 
 6         chars_frequences = [0 for _ in range(26)]
 7         left = 0
 8         right = 0
 9         char_max_frequence = 0
10         max_substring_len = 0
11 
12         while right < len(s):
13             chars_frequences[ord(s[right])-ord('A')] += 1 
14             char_max_frequence = max(chars_frequences)
15 
16             if  char_max_frequence + k >= right - left+1:          
17                 right += 1  
18                 max_substring_len = max(max_substring_len, right-left)  
19             else:
20                 chars_frequences[ord(s[left])-ord('A')] -= 1
21                 left += 1
22                 right += 1
23                 
24         return max_substring_len

View Code

124. 最长连续序列

Clarification

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

 1 class Solution:
 2     """
 3     @param num: A list of integers
 4     @return: An integer
 5     """
 6     def longestConsecutive(self, num):
 7         # write your code here
 8         ans = 1
 9         uniq_num_visted = {n: False for n in num}
10         
11         for n in uniq_num_visted:
12             if uniq_num_visted[n]:
13                 continue
14             
15             uniq_num_visted[n] = True
16             
17             while n + 1 in uniq_num_visted:
18                 uniq_num_visted[n + 1] = True
19                 n += 1
20             high = n
21 
22             while n - 1 in uniq_num_visted:
23                 uniq_num_visted[n - 1] = True
24                 n -= 1
25             low = n
26             
27             ans = max(ans, high-low+1)
28 
29  
30         return ans

View Code

 1 #
 2 # max increasing subsequence
 3 # @param arr int整型一维数组 the array
 4 # @return int整型
 5 #
 6 class Solution:
 7     def MLS(self , arr ):
 8         # write code here
 9         if not arr:
10             return 0
11         arr_set = set(arr)
12         res = 0
13         
14         for key in arr_set:
15             if key - 1 in arr_set:
16                 continue
17             high = key
18             while high + 1 in arr_set:
19                 high = high + 1
20             res = max(res, high-key+1)
21             
22         return res

View Code

567. 字符串的排列

难度中等

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

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

示例1:

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

示例2:

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

注意：

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

 1 class Solution:
 2     def checkInclusion(self, s1: str, s2: str) -> bool:
 3         if len(s1) > len(s2): 
 4             return False
 5         if not s1:
 6             return True
 7 
 8         s1_len = len(s1)
 9         s2_len = len(s2)
10         windows = {}
11         needs = {}
12 
13         for s1_item in s1:
14             needs[s1_item] = needs.setdefault(s1_item, 0) + 1
15     
16         for index in range(s1_len-1):
17             windows[s2[index]] = windows.setdefault(s2[index], 0) + 1
18         
19         for index in range(s1_len-1, s2_len):
20             windows[s2[index]] = windows.setdefault(s2[index], 0) + 1
21             if needs == windows:
22                 return True
23             else:
24                 windows[s2[index-s1_len+1]] -= 1
25                 if windows[s2[index-s1_len+1]] == 0:
26                     windows.pop(s2[index-s1_len+1])
27 
28         return False

View Code

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

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

124. 最长连续序列

Example

Clarification

567. 字符串的排列