2020-05-10

Author: JiayangWu

0021.合并两个有序链表/0021-合并两个有序链表.py

@@ -11,21 +11,23 @@ def mergeTwoLists(self, l1, l2):
         :type l2: ListNode
         :rtype: ListNode
         """
-        newhead = ListNode(0)
-        p = newhead
-        while(l1 and l2):
-            if l1.val < l2.val:
+        dummy = ListNode(-1)
+        
+        p = dummy
+        
+        while l1 and l2:
+            if l1.val <= l2.val:
                 p.next = ListNode(l1.val)
                 l1 = l1.next
             else:
                 p.next = ListNode(l2.val)
                 l2 = l2.next
             p = p.next
-        
+            
         if l1:
             p.next = l1
-        else:
+            
+        if l2:
             p.next = l2
-        return newhead.next
 
-            
+        return dummy.next

0053.最大子序和/0053-最大子序和.py

@@ -6,14 +6,14 @@ def maxSubArray(self, nums):
         """
         if not nums:
             return 0
-        dp = [] # dp[i]表示以i结尾的连续子数组的最大和
+        dp = [0 for _ in nums]
+        dp[0] = nums[0]
+        
         for i, x in enumerate(nums):
-            if i == 0:
-                dp.append(x)
-            else:
-                if dp[-1] < 0:
-                    dp.append(x)
+            if i:
+                if dp[i - 1] > 0:
+                    dp[i] = max(dp[i - 1] + x, dp[i])
                 else:
-                    dp.append(dp[-1] + x)
+                    dp[i] = x
 
         return max(dp)

0098.验证二叉搜索树/0098-验证二叉搜索树.py

@@ -11,10 +11,10 @@ def isValidBST(self, root):
         :type root: TreeNode
         :rtype: bool
         """
-        def inOrder(node):
+        def inorder(node):
             if not node:
                 return []
-            return inOrder(node.left) + [node.val] + inOrder(node.right)
+            return inorder(node.left) + [node.val] + inorder(node.right)
 
-        inorder = inOrder(root)
-        return len(inorder) == len(set(inorder)) and inorder == sorted(inorder)
+        l = inorder(root)
+        return l == sorted(l) and len(l) == len(set(l))

0221.最大正方形/0221-最大正方形.py

@@ -4,37 +4,26 @@ def maximalSquare(self, matrix):
         :type matrix: List[List[str]]
         :rtype: int
         """
-        m = len(matrix)
-        if m == 0:
+        if not matrix or not matrix[0]:
             return 0
-        n = len(matrix[0])
-        if n == 0:
-            return 0
-        self.res = 0
+        m, n = len(matrix), len(matrix[0])
 
-        def find(x, y):
-            for length in range(1, min(m - i, n - j) + 1):#lengthÊDZ߳¤
-                cnt = 0
-                
-                for k in range(length):
-                    for t in range(length):
-                        xx = x + k
-                        yy = y + t
-                        
-                        if 0 <= xx <m and 0 <= yy < n:
-                            if matrix[xx][yy] == "0":
-                                return 
-                            else:
-                                cnt += 1
-                if cnt == length ** 2:
-                    self.res = max(self.res, cnt)
-                                 
-                
+        dp = [[0 for _ in range(n)] for _ in range(m)]
+        res = 0
+        for j in range(n):
+            if matrix[0][j] == "1":
+                dp[0][j] = 1
+                res = 1
 
         for i in range(m):
-            for j in range(n):
+            if matrix[i][0] == "1":
+                dp[i][0] = 1
+                res = 1
+                
+        for i in range(1, m):
+            for j in range(1, n):
                 if matrix[i][j] == "1":
-                    find(i, j)
-                    
-        return self.res
-                           
+                    dp[i][j] = min(dp[i - 1][j - 1], dp[i][j - 1], dp[i - 1][j]) + 1
+                    res = max(res, dp[i][j] ** 2)
+        # print dp
+        return res

0572.另一个树的子树/0572-另一个树的子树.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 isSubtree(self, s, t):
+        """
+        :type s: TreeNode
+        :type t: TreeNode
+        :rtype: bool
+        """
+
+        if not s and not t:
+            return True
+        if s and not t:
+            return False
+        if t and not s:
+            return False
+
+        return self.isSameTree(t, s) or self.isSubtree(s.left, t) or self.isSubtree(s.right, t)
+        
+    def isSameTree(self, t1, t2):
+        if not t1 and not t2:
+            return True
+        if t1 and not t2:
+            return False
+        if t2 and not t1:
+            return False
+        return t1.val == t2.val and self.isSameTree(t1.left, t2.left) and self.isSameTree(t1.right, t2.right)