update

Author: CSStudySession

Meta/LC215 Kth Largest Element in an Array.py

@@ -0,0 +1,47 @@
+from typing import List
+'''
+解法1: min heap.注意入堆操作时 有个优化!
+T: O(n*lg(k))  S:O(k)
+'''
+def findKthLargest0(nums: List[int], k: int) -> int:
+    if not nums:
+        return 0
+    heap = []
+    import heapq # 默认是min heap
+    for num in nums:
+        if len(heap) < k:
+            heapq.heappush(heap, num)
+        elif num > heap[0]: # 优化点!只有在当前num>堆顶时 才进行pushpop操作
+                            # 如果num<=堆顶 则num一定不会是第k大(堆顶比num更有可能是)
+            heapq.heappushpop(heap, num)
+    return heap[0] # 堆顶元素是k个在堆里元素中 最小的 -> 第k大
+
+'''
+解法2: quick select
+随意选一个pivot number, move all smaller to left of pivot, all larger to right of pivot.
+T: avg O(n) worst O(n^2)  S: O(h) due to recursion call.
+'''
+def findKthLargest1(nums: List[int], k: int) -> int:
+    if not nums:
+        return 0
+    k = len(nums) - k
+    return quickSelect(nums, k, 0, len(nums) - 1)
+
+def quickSelect(nums, k, start, end) -> int:
+    pivot = nums[start]
+    left, right = start, end  # 要重新assign pointer, 因为需要left right不断移动
+    while left <= right:
+        while left <= right and nums[left] < pivot:
+            left += 1
+        while left <= right and nums[right] > pivot:
+            right -= 1
+        if left <= right:
+            nums[left], nums[right] = nums[right], nums[left]
+            left += 1
+            right -= 1
+    # 结束的时候left在右 right在左[start, right, left, end]
+    if k >= left:
+        quickSelect(nums, k, left, end)
+    if k <= right:
+        quickSelect(nums, k, start, right)
+    return nums[k]

Meta/LC314 Binary Tree Vertical Order Traversal.py

@@ -0,0 +1,33 @@
+
+from typing import Optional, List, collections
+
+class TreeNode:
+    def __init__(self, val = 0, left = None, right = None):
+        self.val = val
+        self.left = left
+        self.right = right
+
+def verticalOrder(root: Optional[TreeNode]) -> List[List[int]]:
+    if not root:
+        return []
+    
+    ret = []
+    # {col_idx, [list of nodes with column idx as col_idx]}
+    node_dict = collections.defaultdict(list) # dict不是Python keywords, 但不推荐作为变量名
+    queue = collections.deque([(root, 0)]) # 括号里是[(x,y)]形式. root col_idx as 0
+    min_col, max_col = 0, 0
+
+    while queue:
+        node, idx = queue.popleft() # front is at the right-end
+        min_col = min(idx, min_col)
+        max_col = max(idx, max_col)
+        if node.left:
+            queue.append((node.left, idx - 1))
+        if node.right:
+            queue.append((node.right, idx + 1))
+            node_dict[idx].append(node.val)
+    
+    for i in range(min_col, max_col + 1):
+        ret.append(node_dict[i])
+    
+    return ret

Meta/LC408 Valid Word Abbreviation.py

@@ -0,0 +1,48 @@
+'''
+A string can be abbreviated by replacing any number of non-adjacent, non-empty substrings with their lengths. The lengths should not have leading zeros.
+
+For example, a string such as "substitution" could be abbreviated as (but not limited to):
+
+"s10n" ("s ubstitutio n")
+"sub4u4" ("sub stit u tion")
+"12" ("substitution")
+"su3i1u2on" ("su bst i t u ti on")
+"substitution" (no substrings replaced)
+The following are not valid abbreviations:
+
+"s55n" ("s ubsti tutio n", the replaced substrings are adjacent)
+"s010n" (has leading zeros)
+"s0ubstitution" (replaces an empty substring)
+Given a string word and an abbreviation abbr, return whether the string matches the given abbreviation.
+
+A substring is a contiguous non-empty sequence of characters within a string.
+
+Example 1:
+
+Input: word = "internationalization", abbr = "i12iz4n"
+Output: true
+Explanation: The word "internationalization" can be abbreviated as "i12iz4n" ("i nternational iz atio n").
+'''
+
+'''
+solution: two pointers T: O(n)  S: O(n)for tmp字符串构建  
+'''
+
+def validWordAbbreviation(word: str, abbr: str) -> bool:
+    if len(word) < len(abbr): return False # word比abbr还短 一定不会匹配 
+
+    i, j = 0, 0
+    while i < len(word) and j < len(abbr):
+        if word[i] != abbr[j]:
+            if abbr[j] == '0' or not abbr[j].isdigit():
+                return False
+                
+            tmp = '' # 截取abbr当前的数字段
+            while j < len(abbr) and abbr[j].isdigit():
+                tmp += abbr[j]
+                j += 1
+            i += int(tmp) # i跳过长度为tmp的字符串
+        else: # 两个字符相等 各进一步
+            i += 1
+            j += 1
+    return i == len(word) and j == len(abbr) # 一定要都恰好走到最后一个

Meta/LC680 Valid Palindrome II.py

@@ -0,0 +1,31 @@
+'''
+Given a string s, return true if the s can be palindrome after deleting at most one character from it.
+Example 1:
+Input: s = "aba"
+Output: true
+'''
+
+# time O(n) space O(1)
+def validPalindrome(s: str) -> bool:
+    if not s:
+        return True
+    
+    left, right = 0, len(s) - 1
+    while left < right:
+        if s[left] != s[right]: # 要么左边跳过当前字符 要么右边跳过当前字符
+            if is_palindrome(left + 1, right, s) or is_palindrome(left, right - 1, s):
+                return True
+            else: # 只有一次跳过的机会.尝试跳过不成功,直接return False
+                return False
+        else:
+            left += 1
+            right -= 1
+    return True
+
+def is_palindrome(i, j, s) -> bool:
+    while i < j:
+        if s[i] != s[j]:
+            return False
+        i += 1
+        j -= 1
+    return True