2020-10-15

Author: JiayangWu

0198.打家劫舍/0198-打家劫舍.py

@@ -4,15 +4,11 @@ def rob(self, nums):
         :type nums: List[int]
         :rtype: int
         """
-        # return 0
-        if not nums:
+        if len(nums) == 0:
             return 0
-        dp = [0 for _ in nums]
-        dp[0] = nums[0] 
-        for i in range(1, len(nums)):
-            if i == 1:
-                dp[i] = max(dp[0], nums[i])
-            else:
-                dp[i] = max(dp[i - 2] + nums[i], dp[i - 1])
-        return dp[-1]
-            
+        if len(nums) <= 2:
+            return max(nums)
+        nums[1] = max(nums[0], nums[1])
+        for i in range(2, len(nums)):
+            nums[i] = max(nums[i - 2] + nums[i], nums[i - 1])
+        return max(nums) if nums else 0

0200.岛屿数量/0200-岛屿数量.py

@@ -1,33 +1,31 @@
-class Solution(object):
-    def numIslands(self, M):
-        """
-        :type grid: List[List[str]]
-        :rtype: int
-        """
-        if not M or not M[0]:
+class Solution:
+    def numIslands(self, grid: List[List[str]]) -> int:
+        from collections import deque
+        if not grid or not grid[0]:
             return 0
-        m, n = len(M), len(M[0])
-        visited = [[0 for j in range(n)] for i in range(m)]
-        # print visited
+
+        m, n = len(grid), len(grid[0])
+
         dx = [1, -1, 0, 0]
         dy = [0, 0, 1, -1]
-        res = 0
-        
-        def dfs(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 M[x][y] == '1' and visited[x][y] ==0:
-                    visited[x][y] = 1
-                    dfs(x, y)
 
+        res = 0
         for i in range(m):
             for j in range(n):
-                if M[i][j] == '1' and visited[i][j] == 0:
+                if grid[i][j] == "1":
+                    grid[i][j] = "0"
                     res += 1
-                    visited[i][j] = 1
-                    dfs(i, j)
-                    # print visited
 
+                    queue = deque([(i, j)])
+
+                    while queue:
+                        x0, y0 = queue.popleft()
+                        for k in range(4):
+                            x = x0 + dx[k]
+                            y = y0 + dy[k]
+
+                            if 0 <= x < m and 0 <= y < n and grid[x][y] == "1":
+                                grid[x][y] = "0"
+                                queue.append((x, y))
+
         return res

0286.墙与门/0286-墙与门.py

@@ -1,32 +1,29 @@
-class Solution(object):
-    def wallsAndGates(self, rooms):
+class Solution:
+    def wallsAndGates(self, rooms: List[List[int]]) -> None:
         """
-        :type rooms: List[List[int]]
-        :rtype: None Do not return anything, modify rooms in-place instead.
+        Do not return anything, modify rooms in-place instead.
         """
         from collections import deque
+
         if not rooms or not rooms[0]:
             return rooms
-        m, n = len(rooms), len(rooms[0])
-        dx = [1, -1, 0, 0]
-        dy = [0, 0, 1, -1]
         INF = 2147483647
-        queue = deque()
-        def bfs(queue):
-            while queue:
-                pos = queue.popleft()
-                x0, y0 = pos
-                    
-                for k in range(4):
-                    x = x0 + dx[k]
-                    y = y0 + dy[k]
-                    if 0 <= x < m and 0 <= y < n and rooms[x][y] == INF:
-                        rooms[x][y] = rooms[x0][y0] + 1
-                        queue.append((x, y))
-                
+
+        m, n = len(rooms), len(rooms[0])
+        queue = deque() # (x_pos, y_pos, step from a gate)
         for i in range(m):
             for j in range(n):
-                if rooms[i][j] == 0: #ÏÖÔÚ´ÓÿÉÈÃųö·¢
-                    queue.append((i, j))
-        bfs(queue)
-        return rooms
+                if rooms[i][j] == 0:
+                    queue.append((i, j, 0))
+
+        dx = [1, -1, 0, 0]
+        dy = [0, 0, 1, -1]
+        while queue:
+            x_pos, y_pos, step = queue.popleft()
+            for k in range(4):
+                x = x_pos + dx[k]
+                y = y_pos + dy[k]
+
+                if 0 <= x < m and 0 <= y < n and rooms[x][y] == INF:
+                    rooms[x][y] = step + 1
+                    queue.append((x, y, step + 1))

0297.二叉树的序列化与反序列化/0297-二叉树的序列化与反序列化.py

@@ -0,0 +1,51 @@
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Codec:
+    def serialize(self, root):
+        """Encodes a tree to a single string.
+        
+        :type root: TreeNode
+        :rtype: str
+        """
+        if not root:
+            return ""
+        
+        s = ""
+        def preorder(node):
+            if not node:
+                return "#"
+
+            return str(node.val) + "," + preorder(node.left) + "," +preorder(node.right)
+        s = preorder(root)
+        return s
+
+    def deserialize(self, data):
+        """Decodes your encoded data to tree.
+        
+        :type data: str
+        :rtype: TreeNode
+        """
+        if not data or data == "#":
+            return None
+        queue = deque(data.split(","))
+        return self.helper(queue)
+
+    def helper(self, queue):
+        cur = queue.popleft()
+        if cur == "#":
+            return None
+        root = TreeNode(cur)
+        root.left = self.helper(queue)
+        root.right = self.helper(queue)
+
+        return root
+
+# Your Codec object will be instantiated and called as such:
+# ser = Codec()
+# deser = Codec()
+# ans = deser.deserialize(ser.serialize(root))

0653.两数之和IV-输入BST/0653-两数之和IV-输入BST.py

@@ -0,0 +1,30 @@
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution(object):
+    def findTarget(self, root, k):
+        """
+        :type root: TreeNode
+        :type k: int
+        :rtype: bool
+        """
+        values = set()
+
+        self.result = False
+        def inorderTraversal(node):
+            if not node:
+                return []
+            if not self.result:
+                if k - node.val in values:
+                    self.result = True
+                    return
+                values.add(node.val)
+
+                inorderTraversal(node.left)
+                inorderTraversal(node.right)
+        inorderTraversal(root)
+        return self.result
+