2020-11-18

Author: JiayangWu

0079.单词搜索/0079-单词搜索.py

@@ -7,34 +7,31 @@ def exist(self, board, word):
         """
         if not board or not board[0]:
             return False
-        if not word:
-            return True
-        
-        self.res = False
+
+        m, n = len(board), len(board[0])
         dx = [1, -1, 0, 0]
         dy = [0, 0, 1, -1]
-        def dfs(start, x0, y0):
-            if start == len(word) - 1:
+        self.res = False
+        def dfs(word_idx, x0, y0):
+            # print word_idx
+            if word_idx >= len(word):
                 self.res = True
-                return
-            visited.add((x0, y0))
-            
-            for k in range(4):
-                x = x0 + dx[k]
-                y = y0 + dy[k]
-                # print x, y
-                if 0 <= x < m and 0 <= y < n and (x, y) not in visited and board[x][y] == word[start + 1] and not self.res:
-                    visited.add((x, y))
-                    dfs(start + 1, x, y)
-                    visited.remove((x, y))
-            
-        m, n = len(board), len(board[0])
-        # print m * n, len(word)
+                return 
+            if not self.res:
+                for k in range(len(dx)):
+                    x1 = x0 + dx[k]
+                    y1 = y0 + dy[k]
+
+                    if 0 <= x1 < m and 0 <= y1 < n and board[x1][y1] == word[word_idx]:
+                        temp = board[x1][y1]
+                        board[x1][y1] = -1
+                        dfs(word_idx + 1, x1, y1)
+                        board[x1][y1] = temp
         for i in range(m):
             for j in range(n):
                 if board[i][j] == word[0]:
-                    visited = set()
-                    dfs(0, i, j)
-                    if self.res:
-                        return True
-        return False
+                    temp = board[i][j]
+                    board[i][j] = 0
+                    dfs(1, i, j)
+                    board[i][j] = temp
+        return self.res

0314.二叉树的垂直遍历/0314-二叉树的垂直遍历.py

@@ -0,0 +1,32 @@
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    def verticalOrder(self, root):
+        """
+        :type root: TreeNode
+        :rtype: List[List[int]]
+        """
+        if not root:
+            return None
+
+        from collections import defaultdict, deque
+
+        queue = deque([(0, root)])
+        res = defaultdict(list) # key is column idx in the result, value is all elements that have that idx
+        while queue: 
+            col_idx, node = queue.popleft()
+
+            res[col_idx].append(node.val)
+
+            if node.left:
+                queue.append((col_idx - 1, node.left))
+            if node.right:
+                queue.append((col_idx + 1, node.right))
+
+        return [val for idx, val, in sorted(res.items(), key=lambda x: x[0])]
+            

0380.常数时间插入、删除和获取随机元素/0380-常数时间插入、删除和获取随机元素.py

@@ -0,0 +1,67 @@
+import random
+class RandomizedSet(object):
+
+    def __init__(self):
+        """
+        Initialize your data structure here.
+        """
+        self.dic = dict()
+        self.l = []
+
+    def insert(self, val):
+        """
+        Ins
+from typing import ValuesViewerts a value to the set. Returns true if the set did not already contain the specified element.
+        :type val: int
+        :rtype: bool
+        """
+        if val in self.dic:
+            return False
+        else:
+            self.l.append(val)
+            self.dic[val] = len(self.l) - 1
+            return True
+
+
+    def remove(self, val):
+        """
+        Removes a value from the set. Returns true if the set contained the specified element.
+        :type val: int
+        :rtype: bool
+        """
+       
+        if val not in self.dic:
+            return False
+        else:
+            # get the index of the element to be delted
+            index = self.dic[val]
+            self.dic.pop(val)
+
+            # swap the element with the last element
+            self.l[index], self.l[-1] = self.l[-1], self.l[index]
+
+            if index != len(self.l) - 1:
+                # if swap happened, update the index of element that got swapped
+                self.dic[self.l[index]] = index
+
+            self.l.pop()
+
+            return True
+            
+
+
+    def getRandom(self):
+        """
+        Get a random element from the set.
+        :rtype: int
+        """
+        
+        return random.choice(self.l)
+
+
+
+# Your RandomizedSet object will be instantiated and called as such:
+# obj = RandomizedSet()
+# param_1 = obj.insert(val)
+# param_2 = obj.remove(val)
+# param_3 = obj.getRandom()

0445.两数相加II/0445-两数相加II.py

@@ -11,39 +11,68 @@ def addTwoNumbers(self, l1, l2):
         :type l2: ListNode
         :rtype: ListNode
         """
-        s1, s2 = [], []
-        while l1:
-            s1.append(l1.val)
+        def getLinkedListLength(l):
+            length = 0
+            while l:
+                l = l.next
+                length += 1
+            return length
+
+        def printLL(node):
+            l = []
+            while node:
+                l.append(node.val)
+                node = node.next
+            print(l)
+
+        def reverseLL(node):
+            if not node or not node.next:
+                return node
+            p = reverseLL(node.next)
+            node.next.next = node
+            node.next = None
+            return p
+
+        length1 = getLinkedListLength(l1)
+        length2 = getLinkedListLength(l2)
+
+        if length1 < length2:
+            l1, l2 = l2, l1
+            length1, length2 = length2, length1
+
+        dummy = ListNode(-1)
+        p = dummy
+
+        n = length1 - length2
+        while n:
+            p.next = ListNode(l1.val)
             l1 = l1.next
-            
+            p = p.next
+            n -= 1
+
         while l2:
-            s2.append(l2.val)
+            p.next = ListNode(l1.val + l2.val)
+            p = p.next
+            l1 = l1.next
             l2 = l2.next
-        
+
+
+        dummy.next = reverseLL(dummy.next)
+
+        p = dummy.next
         carry = 0
-        cur = ListNode(-1)
-        while s1 or s2:
-            value = carry
-            if s1:
-                value += s1.pop()
-            if s2:
-                value += s2.pop()
-
-            carry = value > 9
-            value %= 10
-            
-            cur.val = value
-            pre = ListNode(-1)
-            pre.next = cur
-            cur = pre
-            
-        if carry: #´¦Àí¿ÉÄܵĽøλ
-            pre.val = 1
-            return pre
-        
-        return pre.next
+        pre = dummy
+        while p:
+            p.val += carry
+            if p.val > 9:
+                p.val -= 10
+                carry = 1
+            else:
+                carry = 0
+            p = p.next
+            pre = pre.next
 
-                
-        
+        if carry:
+            pre.next = ListNode(1)
 
-        
+        return reverseLL(dummy.next)

0723.粉碎糖果/0723-粉碎糖果.py

@@ -0,0 +1,44 @@
+class Solution(object):
+    def candyCrush(self, board):
+        """
+        :type board: List[List[int]]
+        :rtype: List[List[int]]
+        """
+        if not board or not board[0]:
+            return None
+        
+        m, n = len(board), len(board[0])
+        # 1. crush stage
+        
+        # flag all elements to be crushed
+        todo = 0
+        for i in range(m):
+            for j in range(n - 2):
+                if board[i][j] and abs(board[i][j]) == abs(board[i][j + 1]) == abs(board[i][j + 2]):
+                    board[i][j] = board[i][j + 1] = board[i][j + 2] = -abs(board[i][j])
+                    todo = 1
+                    
+        for j in range(n):
+            for i in range(m - 2):
+                if board[i][j] and abs(board[i][j]) == abs(board[i + 1][j]) == abs(board[i + 2][j]):
+                    board[i][j] = board[i + 1][j] = board[i + 2][j] = -abs(board[i][j])
+                    todo = 1
+        # print board, todo
+        # 2. gravity stage
+        for j in range(n):
+            lo, hi = m - 1, m - 1
+            while hi >= 0:
+                while hi >= 0 and board[hi][j] < 0:
+                    hi -= 1
+                
+                if hi >= 0:
+                    board[lo][j] = board[hi][j]
+                    lo -= 1
+                    hi -= 1
+            
+            while lo >= 0:
+                board[lo][j] = 0
+                lo -= 1
+
+        # recursively call this function if more crush is necessary
+        return self.candyCrush(board) if todo else board

0797.所有可能的路径/0797-所有可能的路径.py

@@ -4,19 +4,14 @@ def allPathsSourceTarget(self, graph):
         :type graph: List[List[int]]
         :rtype: List[List[int]]
         """
-        res = list()
         n = len(graph)
-        def dfs(start, tmp):
-            if graph[start] == [] and start == n - 1:#ûÓÐÏÂÒ»¸ö½Úµã
-                tmp += graph[start]
-                res.append(tmp[:])
+        visited = set()
+        def dfs(cur_node, path):
+            if cur_node == n - 1:
+                res.append(path[:])
                 return
-            
-            l = graph[start]
-            for node in l:
-                tmp.append(node)
-                dfs(node, tmp)
-                tmp.pop()
-
-        dfs(0, [0])        
+            for next_node in graph[cur_node]:
+                dfs(next_node, path + [next_node])
+        res = []
+        dfs(0, [0])
         return res

0987.二叉树的垂序遍历/0987-二叉树的垂序遍历.py

@@ -0,0 +1,28 @@
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    def verticalTraversal(self, root):
+        """
+        :type root: TreeNode
+        :rtype: List[List[int]]
+        """
+        from collections import defaultdict
+        dic = defaultdict(list) 
+        def dfs(root, x, y): 
+            if root:
+                dic[x].append((y, root.val))
+                dfs(root.left, x - 1, y + 1) 
+                dfs(root.right, x + 1, y + 1) 
+
+        dfs(root, 0, 0) 
+        res = []
+        for k in sorted(dic.keys()): 
+            x = [pair[1] for pair in sorted(dic[k])] 
+            res.append(x)
+
+        return res

1396.设计地铁系统/1396-设计地铁系统.py

@@ -0,0 +1,48 @@
+class UndergroundSystem(object):
+
+    def __init__(self):
+        self.check_in_history = dict() # key is id + stationName, val is t
+        self.StationTraverlTime = dict()
+    def checkIn(self, id, stationName, t):
+        """
+        :type id: int
+        :type stationName: str
+        :type t: int
+        :rtype: None
+        """
+        self.check_in_history[str(id)] = [stationName, t]
+
+
+    def checkOut(self, id, stationName, t):
+        """
+        :type id: int
+        :type stationName: str
+        :type t: int
+        :rtype: None
+        """
+        start_station, start_time = self.check_in_history[str(id)]
+        self.check_in_history.pop(str(id))
+        time_spent = t - start_time
+        key = start_station + "#" + stationName
+        if key not in self.StationTraverlTime:
+            self.StationTraverlTime[key] = [time_spent,1]
+        else:
+            self.StationTraverlTime[key][0] += time_spent
+            self.StationTraverlTime[key][1] += 1
+
+
+    def getAverageTime(self, startStation, endStation):
+        """
+        :type startStation: str
+        :type endStation: str
+        :rtype: float
+        """
+        key = startStation + "#" + endStation
+        return self.StationTraverlTime[key][0] * 1.0 / self.StationTraverlTime[key][1]
+
+
+# Your UndergroundSystem object will be instantiated and called as such:
+# obj = UndergroundSystem()
+# obj.checkIn(id,stationName,t)
+# obj.checkOut(id,stationName,t)
+# param_3 = obj.getAverageTime(startStation,endStation)