update

Author: CSStudySession

Array/LC56MergeIntervals.py

@@ -1,15 +1,18 @@
 from typing import List
-
-class Solution:
-    def merge(self, intervals: List[List[int]]) -> List[List[int]]:
-        ret = []
-        intervals = sorted(intervals) # sorted on first element of inner list
-        cur_left, cur_right = intervals[0][0], intervals[0][1]
-        for i in range(1, len(intervals)):
-            if intervals[i][0] > cur_right:
-                ret.append([cur_left, cur_right])
-                cur_left, cur_right = intervals[i][0], intervals[i][1]
-            else:
-                cur_right = max(cur_right, intervals[i][1])
-        ret.append([cur_left, cur_right]) # last interval needs to process outside of for loop
-        return ret
+'''
+Time o(nlogn) for sorting, Space o(1)
+if current interval does not overlap with the previous: append previous one to result.
+else, if overlap: update previous ending to be max(current, previous)
+'''
+def merge(intervals: List[List[int]]) -> List[List[int]]:
+    ret = []
+    intervals = sorted(intervals) # sorted on first element of inner list
+    prev_left, prev_right = intervals[0][0], intervals[0][1]
+    for i in range(1, len(intervals)):
+        if intervals[i][0] > prev_right:
+            ret.append([prev_left, prev_right])
+            prev_left, prev_right = intervals[i][0], intervals[i][1]
+        else:
+            prev_right = max(prev_right, intervals[i][1]) # 注意这里只更新right 不能append. 后面可能还有重叠的intervals
+    ret.append([prev_left, prev_right]) # last interval needs to process outside of for loop
+    return ret

BFS/LC1091ShortestPathInBinaryMatrix.py

@@ -1,23 +1,96 @@
-from typing import List
-from collections import deque
+from typing import List, collections
 
-class Solution:
-    def shortestPathBinaryMatrix(self, grid: List[List[int]]) -> int:
-        size = len(grid) - 1
-        if grid[0][0] == 1 or grid[size][size] == 1: return -1
-        if len(grid) == 1: return 1
+# 解法1: bfs. 直接修改输入 优化空间复杂度. T(m*n) S(n*n) 每个格子最多处理1次
+def shortestPathBinaryMatrix(grid: List[List[int]]) -> int:
+    size = len(grid) - 1
+    if grid[0][0] == 1 or grid[size][size] == 1:
+        return -1
+    if len(grid) == 1: # n * n 只有1个格子
+        return 1
+    
+    dx = [0, 1, 0, -1, 1, 1, -1, -1]
+    dy = [1, 0, -1, 0, 1, -1, 1, -1]
+    step = 0
+    queue = collections.deque([(0,0)])
+    grid[0][0] = 1 # 把走过的路变成obsticles 节省用visited
+    while queue:
+        step += 1 # 这里加step 之后不用加了
+        for i in range(len(queue)):
+            x, y = queue.popleft()
+            if x == size and y == size:
+                return step
+            for d in range(8):
+                newx = x + dx[d]
+                newy = y + dy[d]
+                if 0 <= newx <= size and 0 <= newy <= size and grid[newx][newy] == 0:
+                    queue.append((newx, newy))
+                    grid[newx][newy] = 1 # mark visited
+    return -1
 
-        queue, level = deque([(0,0)]), 2 # at least two cells: start and end cells
-        while queue:
-            for _ in range(len(queue)):
-                coord_y, coord_x = queue.popleft()
-                for (dx,dy) in ((0, -1), (-1, -1), (-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1)):
-                    nx, ny = coord_x + dx, coord_y + dy
-                    if nx < 0 or ny < 0 or nx > size or ny > size or grid[ny][nx] != 0: # filter out unfeasible cell
-                        continue
-                    if ny == size and nx == size: # find end cell
-                        return level
-                    grid[ny][nx] = 2 # act as a visted set
-                    queue.append((ny, nx)) # enqueue a feasible new cell
-            level += 1
-        return -1 
+# variant: return one shorest path. 
+# bfs的过程中 用dict[(nx, ny)] = (x, y)表示从(x,y)走到的(nx,ny). 在终点back trace回去.
+def oneShortestPathBinaryMatrix(grid: List[List[int]]) -> List[tuple[int]]:
+    size = len(grid) - 1
+    if grid[0][0] == 1 or grid[size][size] == 1:
+        return []
+    if len(grid) == 1: # n * n 只有1个格子
+        return [(0, 0)]
+    
+    dx = [0, 1, 0, -1, 1, 1, -1, -1]
+    dy = [1, 0, -1, 0, 1, -1, 1, -1]
+    step = 0
+    queue = collections.deque([(0,0)])
+    trace = collections.defaultdict(tuple)
+    grid[0][0] = 1 # 把走过的路变成obsticles 节省用visited
+    while queue:
+        step += 1 # 这里加step 之后不用加了
+        for _ in range(len(queue)):
+            x, y = queue.popleft()
+            if x == size and y == size:
+                ret = collections.deque()
+                ret.appendleft((x, y))
+                while (x, y) != (0 ,0):
+                    (x, y) = trace[(x, y)]
+                    ret.appendleft((x, y))
+                return ret
+            for d in range(8):
+                newx = x + dx[d]
+                newy = y + dy[d]
+                if 0 <= newx <= size and 0 <= newy <= size and grid[newx][newy] == 0:
+                    queue.append((newx, newy))
+                    trace[(newx, newy)] = (x, y)
+                    grid[newx][newy] = 1 # mark visited
+    return []
+
+# variant: return any one path, not necessary shorest. 
+# 解法:DFS.
+def onePathBinaryMatrix(grid: List[List[int]]) -> List[tuple[int]]:
+    if not grid or grid[0][0] != 0 or grid[len(grid) - 1][len(grid[0]) - 1] != 0:
+        return -1
+    tmp = [(0,0)]
+    ret = []
+    grid[0][0] = 1
+    dfs(ret, tmp, grid, 0, 0)
+    return ret
+    
+def dfs(ret, tmp, grid, x, y):
+    if len(ret) > 0: # 找到一个解
+        return
+    if x == len(grid) - 1 and y == len(grid[0]) - 1:
+        ret.append(tmp[:]) # 这里要深拷贝
+        return
+    
+    dx = [0, 1, 0, -1, 1, 1, -1, -1]
+    dy = [1, 0, -1, 0, -1, 1, 1, -1]
+    for i in range(8):
+        nx, ny = x + dx[i], y + dy[i]
+        if 0 <= nx <= len(grid) - 1 and 0 <= ny <= len(grid[0]) - 1 and grid[nx][ny] == 0:
+            grid[nx][ny] = 1 # mark visted
+            tmp.append((nx, ny)) # add trace
+            dfs(ret, tmp, grid, nx, ny)
+            tmp.pop()  # restore status
+            grid[nx][ny] = 0
+
+grid0 = [[0,0,0],[1,1,0],[1,1,0]]
+grid1 = [[0,1],[1,0]]
+print(oneShortestPathBinaryMatrix(grid1))

BinarySearch/LC162FindPeakElement.py

@@ -1,15 +1,17 @@
 from typing import List
+'''
+A peak element is an element that is strictly greater than its neighbors. 
+You may imagine that nums[-1] = nums[n] = -∞
+'''
+def findPeakElement(nums: List[int]) -> int: # 返回peak item的index
+    if len(nums) == 1:
+        return 0
 
-class Solution:
-    def findPeakElement(self, nums: List[int]) -> int:
-        if len(nums) == 1:
-            return 0
-
-        left, right = 0, len(nums) - 1
-        while left < right:
-            mid = (left + right) // 2
-            if nums[mid] > nums[mid + 1]: # ans in [left, mid]
-                right = mid
-            else:
-                left = mid + 1
-        return right
+    left, right = 0, len(nums) - 1
+    while left < right:
+        mid = (left + right) // 2
+        if nums[mid] > nums[mid + 1]: # ans in [left, mid]
+            right = mid
+        else:
+            left = mid + 1
+    return right

DataStructure/LC346MovingAverageFromDataStream.py

@@ -3,9 +3,9 @@
 class MovingAverage:
 
     def __init__(self, size: int):
-        self.queue = collections.queue()
-        self.size = size
-        self.total = 0
+        self.queue = collections.deque()
+        self.size = size # 队列目标长度(非实际长度)
+        self.total = 0   # 队列内数值之和
 
 
     def next(self, val: int) -> float:

Meta/LC1 Two Sum.py

@@ -0,0 +1,42 @@
+from typing import List, collections
+# Meta variant 1: return True or False
+def has_two_sum(nums: List[int], target) -> bool:
+    if not nums:
+        return False
+    seen_set = set()
+    for num in nums:
+        other = target - num
+        if other in seen_set:
+            return True
+        seen_set.add(num)
+    return False
+
+# Meta variant 2. Given list of pairs[[x1, x2], ...] and a target, 
+# return number of unique pairs [a1, a2] and [b1, b2] where a1+b1=target and a2+b2=target
+# numbers are limited to digits 0-9. same pair can't be used with itself.
+# 思路:linear scan + dict. dict记录扫描过的pair出现的次数.每次用当前pair去检查dict里是否有加起来等于target的pairs
+def unique_pairs(pairs: List[List[int]], target: int) -> int:
+    if not pairs:
+        return 0
+    pair_to_freq = collections.defaultdict(int)
+    ret = 0
+    for pair in pairs:
+        first, second = target - pair[0], target - pair[1]
+        if (first, second) in pair_to_freq:
+            ret += pair_to_freq[(first, second)]
+        pair_to_freq[(pair[0], pair[1])] += 1 # 注意这里用pair而非(first,second)更新dict
+    return ret
+# test
+pairs = [[3,4], [1,9], [3,4], [2,1],[9,1], [9,1], [7,6], [1,9]]
+target = 10
+print(unique_pairs(pairs, target))
+
+# leetcode version. 
+def twoSum(nums: List[int], target: int) -> List[int]:
+    if not nums: return [-1, -1]
+    dict = {} # 存num和对应的下标
+    for i in range(len(nums)):
+        if target - nums[i] not in dict:
+            dict[nums[i]] = i
+        else:
+            return [i, dict[target - nums[i]]]

Meta/LC138 Copy List with Random Pointer.py

@@ -0,0 +1,36 @@
+
+class Node:
+    def __init__(self, x: int, next: 'Node' = None, random: 'Node' = None):
+        self.val = int(x)
+        self.next = next
+        self.random = random
+
+def copyRandomList(head: 'Optional[Node]') -> 'Optional[Node]':
+    if not head: 
+        return None
+    dummy = Node(0)
+    dummy.next = head
+
+    # copy node. copy placed at the next of original
+    # dummy -> o1->c1->o2->c2-> ...
+    while head:
+        copy = Node(head.val)
+        copy.next = head.next
+        head.next = copy
+        head = head.next.next
+
+    # copy random
+    head = dummy.next
+    while head and head.next: # must have head.next
+        if head.random: # some random is null
+            head.next.random = head.random.next # head.random的next是h.random的copy 
+        head = head.next.next # 已经插入 要走两步
+    
+    # split
+    head = dummy.next.next
+    res = dummy.next.next
+    while head and head.next:
+        tmp = head.next.next
+        head.next = tmp
+        head = head.next  # 已经去掉原来的head.next 只走一步
+    return res

Meta/LC146 LRU Cache.py

@@ -0,0 +1,114 @@
+from typing import collections
+
+# Meta variant: 多实现两个接口 del(key) -> bool, last() -> int
+# last()返回most recent used value if there's.
+# get, put, del run O(1) average, last runs O(1)
+# no capacity requiement: no limitation on capacity
+class Node:
+    def __init__(self, key, value):
+        self.key = key
+        self.value = value
+        self.next = None
+        self.prev = None
+class LRU_cache_v1:
+    def __init__(self): # 注意没有capacity限制了
+        self.head = Node(0,0)
+        self.tail = Node(-1,-1)
+        self.head.next = self.tail
+        self.tail.prev = self.head
+        self.val_to_ref = collections.defaultdict(Node)
+    
+    def reconnect_nodes(self, node: Node): # helper func
+        prev = node.prev
+        next = node.next
+        prev.next = next
+        next.prev = prev
+
+    def move_to_end(self, node: Node):
+        before = self.tail.prev
+        before.next = node
+        node.prev = before
+
+        node.next = self.tail
+        self.tail.prev = node
+    
+    def get(self, key: int) -> int:
+        if key not in self.val_to_ref:
+            return -1
+        cur = self.val_to_ref[key]
+        val = cur.value
+        self.reconnect_nodes(cur)
+        self.move_to_end(cur)
+        return val
+
+    def put(self, key:int, val:int):
+        if key in self.val_to_ref: # 之前存在 先删掉 再插入新的
+            cur = self.val_to_ref[key]
+            self.reconnect_nodes(cur)
+            del self.val_to_ref[key]
+        
+        cur = Node(key, val)
+        self.val_to_ref[key] = cur
+        self.move_to_end(cur)
+    
+    def delelte_key(self, key:int) -> bool:
+        if key not in self.val_to_ref:
+            return False
+        remove = self.val_to_ref[key]
+        self.reconnect_nodes(remove)
+        del self.val_to_ref[key]
+        return True
+
+    def last(self) -> int:
+        if self.tail.prev == self.head: # cache为空
+            return -1
+        return self.tail.prev.value # tail之前的节点一直是most recent used one
+
+# leetcode version
+class LRUCache:
+    def __init__(self, capacity: int):
+        self.capacity = capacity
+        # 创建两个dummy, 一个head一个tail
+        self.head = Node(0, 0)
+        self.tail = Node(0, 0)
+        self.head.next = self.tail
+        self.tail.prev = self.head
+
+        self.dict = {} 
+
+    def get(self, key: int) -> int:
+        if key not in self.dict:          
+            return -1
+        else:
+            node = self.dict[key] 
+            self.remove(node)
+            self.add(node)         
+            return node.value
+
+    def put(self, key: int, value: int) -> None:
+        newnode = Node(key, value) #注意这里的处理 需要先new一个新node
+        if key in self.dict: # 这里要remove oldnode, add newnode
+            oldnode = self.dict[key]
+            self.remove(oldnode)
+            self.add(newnode)
+            self.dict[key] = newnode
+        else:
+            self.add(newnode) #每次的add/remove dict里面都要一起
+            self.dict[key] = newnode
+            if len(self.dict) > self.capacity:
+                toRemove = self.head.next
+                self.remove(toRemove)
+                del self.dict[toRemove.key]    
+        
+    # head -> 0 -> 1 -> tail
+    #只需要用到add to tail(this is the dummy tail node)
+    def add(self, node):
+        tailpre = self.tail.prev
+        tailpre.next = node
+        node.prev = tailpre
+        node.next = self.tail
+        self.tail.prev = node
+
+    def remove(self, node):
+        node.prev.next = node.next
+        node.next.prev = node.prev