2019-07-14

Author: JiayangWu

5127.数组的相对排序/5127-数组的相对排序.py

@@ -0,0 +1,25 @@
+class Solution(object):
+    def relativeSortArray(self, arr1, arr2):
+        """
+        :type arr1: List[int]
+        :type arr2: List[int]
+        :rtype: List[int]
+        """
+        from collections import defaultdict
+        res = []
+        left = [] #存放没有在arr2里出现过的数字
+        set2 = set(arr2) #把arr2转成set，让查找的时间复杂度降低到O(1)
+       
+        dic = defaultdict(int) #记录arr1中数字出现的频率
+        for num in arr1:
+            if num in set2:
+                dic[num] += 1
+            else:
+                left.append(num)
+
+        for num in arr2:
+            res += [num] * dic[num]
+
+        left.sort() #按照题目要求把没出现过的元素排序
+        return res + left
+            

5128.最深叶节点的最近公共祖先/5128-最深叶节点的最近公共祖先.py

@@ -0,0 +1,71 @@
+# 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 lcaDeepestLeaves(self, root):
+        """
+        :type root: TreeNode
+        :rtype: TreeNode
+        """
+        def inorder(node):
+            if not node:
+                return []
+            return inorder(node.left) + [node.val] + inorder(node.right)
+        # print inorder(root)
+        if not root or (not root.left and not root.right):
+            return root
+        
+        dic = {}
+        def depth(node, tmp):
+            if not node:
+                return
+            dic[node] = tmp + 1
+            depth(node.left, tmp + 1)
+            depth(node.right, tmp + 1)
+            
+        depth(root, 0)
+        # print dic
+        l = []
+        max_depth = max(dic.values())
+        for key, val in dic.items():
+            if val == max_depth:
+                l.append(key)
+                
+        if len(l) == 1:
+            return l[0]
+        # print l
+        tmpAncestor = None
+        if len(l) >= 2:
+            tmpAncestor = self.lowestCommonAncestor(root, l[0], l[1])
+        for i in range(2, len(l), 1):
+            tmpAncestor = self.lowestCommonAncestor(root, tmpAncestor, l[i])
+        return tmpAncestor
+            
+        
+        
+    def lowestCommonAncestor(self, root, p, q):
+        """
+        :type root: TreeNode
+        :type p: TreeNode
+        :type q: TreeNode
+        :rtype: TreeNode
+        """
+        
+        if not root or root == p or root == q:
+            return root
+        else:
+            left = self.lowestCommonAncestor(root.left, p, q)
+            right = self.lowestCommonAncestor(root.right, p, q)
+            
+            if left and right: #一个在左子树，一个在右子树
+                return root
+            elif left:#都在左子树
+                return left
+            elif right:#都在右子树
+                return right
+            else:
+                return

5129.表现良好的最长时间段/5129-表现良好的最长时间段.py

@@ -0,0 +1,27 @@
+class Solution(object):
+    def longestWPI(self, hours):
+        """
+        :type hours: List[int]
+        :rtype: int
+        """
+        n = len(hours)
+        a = [0]*n
+        for i,hour in enumerate(hours):
+            if hour>8:
+                a[i]=1
+            else:
+                a[i]=-1
+        for i in range(1,n):
+            a[i]+=a[i-1]
+        b={}
+        res = 0
+        for i in range(n):
+            if a[i]>0:
+                res = max(res,i+1)
+            else:
+                if a[i]-1 in b:
+                    res = max(res,i-b[a[i]-1])
+                if a[i] not in b:
+                    b[a[i]]=i
+        return res
+