2020-10-15

Author: JiayangWu

0036.有效的数独/0036-有效的数独.py

@@ -1,19 +1,15 @@
-class Solution(object):
-    def isValidSudoku(self, board):
-        """
-        :type board: List[List[str]]
-        :rtype: bool
-        """
-        from collections import defaultdict
-        row, column, squre  = defaultdict(set), defaultdict(set), defaultdict(set)
+class Solution:
+    def isValidSudoku(self, board: List[List[str]]) -> bool:
+        row = defaultdict(set)
+        col = defaultdict(set)
+        square = defaultdict(set)
         for i in range(9):
             for j in range(9):
                 if board[i][j].isdigit():
-                    if board[i][j] in row[i] or board[i][j] in column[j] or board[i][j] in squre[(i//3, j//3)]:
+                    if board[i][j] in row[i] or board[i][j] in col[j] or board[i][j] in square[(i // 3, j // 3)]:
                         return False
                     else:
                         row[i].add(board[i][j])
-                        column[j].add(board[i][j])
-                        squre[(i//3, j //3)].add(board[i][j])
+                        col[j].add(board[i][j])
+                        square[(i // 3, j // 3)].add(board[i][j])
         return True
-                

0037.解数独/0037-解数独.py

@@ -1,48 +1,66 @@
-class Solution(object):
-    def solveSudoku(self, board):
+from collections import defaultdict
+import copy
+class Solution:
+    def solveSudoku(self, board: List[List[str]]) -> None:
         """
-        :type board: List[List[str]]
-        :rtype: None Do not return anything, modify board in-place instead.
+        Do not return anything, modify board in-place instead.
         """
-        from collections import defaultdict
-        row, column, squre  = defaultdict(set), defaultdict(set), defaultdict(set)
-        
+        row = defaultdict(set)
+        col = defaultdict(set)
+        square = defaultdict(set)
+        for i in range(9):
+            for j in range(9):
+                if board[i][j].isdigit():
+                    row[i].add(board[i][j])
+                    col[j].add(board[i][j])
+                    square[(i // 3, j // 3)].add(board[i][j])
         self.res = []
         def dfs(x, y):
-            
-            if x == 8 and y == 9:
-                # print board
-                for roww in board:
-                    self.res.append(roww[:])
-                # print self.res
+            if x == 9 and y == 0:
+                if self.isValidSudoku(board):
+                    self.res = copy.deepcopy(board)
                 return
-            if y == 9:
-                dfs(x + 1, 0)
-                return
-            if board[x][y].isdigit():
-                dfs(x, y + 1)
-                return
-                
-            for k in range(1,10):
-                if str(k) not in row[x] and str(k) not in column[y] and str(k) not in squre[(x // 3, y // 3)]:
-                    board[x][y] = str(k)
-                    row[x].add(str(k))
-                    column[y].add(str(k))
-                    squre[(x // 3, y // 3)].add(str(k))
-                    
-                    dfs(x, y + 1)
-                    
-                    board[x][y] = "."
-                    row[x].remove(str(k))
-                    column[y].remove(str(k))
-                    squre[(x // 3, y // 3)].remove(str(k))
 
+            if not self.res:
+                if board[x][y] != ".":
+                    if y == 8:
+                        dfs(x + 1, 0)
+                    else:
+                        dfs(x, y + 1)
+                    return
+                
+                for num in range(1, 10):
+                    num = str(num)
+                    if num not in row[x] and num not in col[y] and num not in square[(x // 3, y // 3)]:
+                        board[x][y] = num
+
+                        row[x].add(num)
+                        col[y].add(num)
+                        square[(x // 3, y // 3)].add(num)
+                        if y == 8:
+                            dfs(x + 1, 0)
+                        else:
+                            dfs(x, y + 1)
+                        board[x][y] = "."
+                        row[x].remove(num)
+                        col[y].remove(num)
+                        square[(x // 3, y // 3)].remove(num)
+
+        dfs(0, 0)
+        board[:] = self.res
+
+
+    def isValidSudoku(self, board: List[List[str]]) -> bool:
+        row = defaultdict(set)
+        col = defaultdict(set)
+        square = defaultdict(set)
         for i in range(9):
             for j in range(9):
                 if board[i][j].isdigit():
-                    row[i].add(board[i][j].encode("utf-8"))
-                    column[j].add(board[i][j].encode("utf-8"))
-                    squre[(i // 3, j // 3)].add(board[i][j].encode("utf-8"))
-
-        dfs(0, 0)
-        board[:] = self.res
+                    if board[i][j] in row[i] or board[i][j] in col[j] or board[i][j] in square[(i // 3, j // 3)]:
+                        return False
+                    else:
+                        row[i].add(board[i][j])
+                        col[j].add(board[i][j])
+                        square[(i // 3, j // 3)].add(board[i][j])
+        return True

0084.柱状图中最大的矩形/0084-柱状图中最大的矩形.py

@@ -1,15 +1,12 @@
-class Solution(object):
-    def largestRectangleArea(self, heights):
-        """
-        :type heights: List[int]
-        :rtype: int
-        """
+class Solution:
+    def largestRectangleArea(self, heights: List[int]) -> int:
         heights = [0] + heights + [0]
-        stack = []
         res = 0
-        for i, num in enumerate(heights):
-            while stack and heights[stack[-1]] > num:
-                    top = stack.pop()
-                    res = max(res, (i - stack[-1] - 1) * heights[top])
+        stack = []
+        for i in range(len(heights)):
+            while stack and heights[stack[-1]] > heights[i]:
+                top = stack.pop()
+                res = max(res, (i - stack[-1] - 1) * heights[top])
+
             stack.append(i)
         return res

0091.解码方法/0091-解码方法.py

@@ -0,0 +1,39 @@
+class Solution:
+    def numDecodings(self, s: str) -> int:
+        if not s or s[0] == "0":
+            return 0
+
+        dp = [0]*(len(s) + 1) # dp[i] represents ways of s[:i + 1]
+        dp[1] = dp[0] = 1
+
+        for i in range(2, len(s) + 1):
+            if s[i - 1] == "0":
+                if s[i - 2] in ["1", "2"]:
+                    dp[i] = dp[i - 2]
+                else:
+                    return 0
+            elif s[i - 2] == "1" or (s[i - 2] == "2" and "1" <= s[i - 1] <= "6"):
+                dp[i] = dp[i - 1] + dp[i - 2]
+            else:
+                dp[i] = dp[i - 1]
+        return dp[-1]
+
+        # dp = [0]*(len(s) + 1)
+        # if s[0] == '0':
+        #     return 0
+        # dp[0] = 1
+        # dp[1] = 1
+        # for i in range(2, len(s)+1):
+        #     if s[i-1] == '0' :
+        #         if s[i-2] in ['1', '2']:
+        #             dp[i] = dp[i-2]
+        #         else:
+        #             return 0
+        #     elif s[i-2] == '1' or (s[i-2] == '2' and '1' <= s[i-1] <= '6'):
+        #         dp[i] = dp[i-1] + dp[i-2]
+        #     else:
+        #         dp[i] = dp[i-1]
+        # return dp[-1]
+
+
+

0100.相同的树/0100-相同的树.py

@@ -1,20 +1,18 @@
 # Definition for a binary tree node.
-# class TreeNode(object):
+# class TreeNode:
 #     def __init__(self, val=0, left=None, right=None):
 #         self.val = val
 #         self.left = left
 #         self.right = right
-class Solution(object):
-    def isSameTree(self, p, q):
-        """
-        :type p: TreeNode
-        :type q: TreeNode
-        :rtype: bool
-        """
+class Solution:
+    def isSameTree(self, p: TreeNode, q: TreeNode) -> bool:
         if not p and not q:
             return True
+
         if not p and q:
             return False
+        
         if p and not q:
-            return False 
+            return False
+
         return p.val == q.val and self.isSameTree(p.left, q.left) and self.isSameTree(p.right, q.right)

0139.单词拆分/0139-单词拆分.py

@@ -1,17 +1,13 @@
-class Solution(object):
-    def wordBreak(self, s, wordDict):
-        """
-        :type s: str
-        :type wordDict: List[str]
-        :rtype: bool
-        """
-        dp = [0]
-        
-        for j in range(len(s) + 1):
-            for i in dp:
-                if s[i:j] in wordDict:
-                    dp.append(j)
+class Solution:
+    def wordBreak(self, s: str, wordDict: List[str]) -> bool:
+        from collections import deque
+        wordDict = set(wordDict)
+        record = [0]
+
+        for i in range(len(s) + 1):
+            for j in record:
+                if s[j:i] in wordDict:
+                    record.append(i)
                     break
-        # print dp
-        return dp[-1] == len(s)
-                    
+        # print (record)
+        return record[-1] == len(s)

0140.单词拆分II/0140-单词拆分II.py

@@ -0,0 +1,22 @@
+class Solution:
+    def wordBreak(self, s: str, wordDict: List[str]) -> List[str]:
+    
+        def helper(s, memo):
+            if s in memo: 
+                return memo[s]
+            if not s: 
+                return []
+            res = []
+            for word in wordDict:
+                if not s.startswith(word):
+                    continue
+                if len(word) == len(s):
+                    res.append(word)
+                else:
+                    resultOfTheRest = helper(s[len(word):], memo)
+                    for item in resultOfTheRest:
+                        item = word + ' ' + item
+                        res.append(item)
+            memo[s] = res
+            return res
+        return helper(s, {})

0207.课程表/0207-课程表.py

@@ -1,35 +1,29 @@
-class Solution(object):
-    def canFinish(self, numCourses, prerequisites):
-        """
-        :type numCourses: int
-        :type prerequisites: List[List[int]]
-        :rtype: bool
-        """
-        from collections import deque
-        if not prerequisites: #没有前置课的要求
-            return True
-        
-        indegree = [0 for _ in range(numCourses)]
-        adj = [set() for _ in range(numCourses)]
-        
-        for end, start in prerequisites:
-            indegree[end] += 1
-            adj[start].add(end)
-        
-        queue = deque()
-        for i, x in enumerate(indegree):
-            if not x: #入度为0的结点入队
-                queue.append(i)
-        
-        cnt = 0
+class Solution:
+    def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
+        # 1. find all node/course with indegree 0, let them enter a queue
+        from collections import defaultdict, deque
+        indegree = defaultdict(int)
+        children = defaultdict(set)
+        all_courses = set()
+        for cur, pre in prerequisites:
+            indegree[cur] += 1
+            children[pre].add(cur)
+            all_courses.add(cur)
+            all_courses.add(pre)
+
+        queue = deque([])
+        for course in all_courses:
+            if indegree[course] == 0:
+                queue.append(course)
+        # 2. BFS, let course with indegree 0 leave a queue, and let its children with indegree 0 into the queue
+        studied_course = 0
         while queue:
             cur = queue.popleft()
-            cnt += 1 #当前的cur满足条件
-            
-            for neighbor in adj[cur]:
-                indegree[neighbor] -= 1
-                if not indegree[neighbor]:
-                    queue.append(neighbor)
-    
-        return cnt == numCourses
-                    
+
+            studied_course += 1
+            for child in children[cur]:
+                indegree[child] -= 1
+                if indegree[child] == 0:
+                    queue.append(child)
+
+        return studied_course == len(all_courses)