第二周作业#014

Week_02/id_14/LeetCode_111_14.py.txt

@@ -0,0 +1,19 @@
+# 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 minDepth(self, root):
+        """
+        :type root: TreeNode
+        :rtype: int
+        """
+        if root == None:
+            return 0
+        if root.left==None or root.right==None:
+            return self.minDepth(root.left)+self.minDepth(root.right)+1
+        return min(self.minDepth(root.right),self.minDepth(root.left))+1
+

Week_02/id_14/LeetCode_1_14.py.txt

@@ -0,0 +1,14 @@
+class Solution(object):
+    def twoSum(self, nums, target):
+        """
+        :type nums: List[int]
+        :type target: int
+        :rtype: List[int]
+        """
+        obj = {}
+        for i in range(len(nums)):
+            num = nums[i]
+            if target - num in obj:
+                return obj[target-num], i
+            if num not in obj:
+                obj[num] = i

Week_02/id_14/LeetCode_242_14.py.txt

@@ -0,0 +1,8 @@
+class Solution(object):
+    def isAnagram(self, s, t):
+        """
+        :type s: str
+        :type t: str
+        :rtype: bool
+        """
+        return sorted(s) == sorted(t)

Week_02/id_14/LeetCode_3_14.py.txt

@@ -0,0 +1,14 @@
+class Solution:
+    def lengthOfLongestSubstring(self, s):
+        """
+        :type s: str
+        :rtype: int
+        """
+        st = {}
+        i, ans = 0, 0
+        for j in range(len(s)):
+            if s[j] in st:
+                i = max(st[s[j]], i)
+            ans = max(ans, j - i + 1)
+            st[s[j]] = j + 1
+        return ans

Week_02/id_14/LeetCode_692_14.py.txt

@@ -0,0 +1,7 @@
+class Solution(object):
+    def topKFrequent(self, words, k):
+        obj = {}
+        for word in words:
+            obj[word] = obj.get(word, 0) + 1
+        ret = sorted(obj, key=lambda word: (-obj[word], word))
+        return ret[:k]

Week_03/id_14/LeetCode_104_14.py.txt

@@ -0,0 +1,14 @@
+# 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 maxDepth(self, root):
+        """
+        :type root: TreeNode
+        :rtype: int
+        """
+        return 1 + max(map(self.maxDepth, (root.left, root.right))) if root else 0

Week_03/id_14/LeetCode_429_14.py.txt

@@ -0,0 +1,27 @@
+"""
+# Definition for a Node.
+class Node(object):
+    def __init__(self, val, children):
+        self.val = val
+        self.children = children
+"""
+class Solution(object):
+    def levelOrder(self, root):
+        """
+        :type root: Node
+        :rtype: List[List[int]]
+        """
+        if not root:
+            return []
+        res = []
+        stack = [root]
+        while stack:
+            temp = []
+            next_stack = []
+            for node in stack:
+                temp.append(node.val)
+                for child in node.children:
+                    next_stack.append(child)
+            stack = next_stack
+            res.append(temp)
+        return res

Week_03/id_14/LeetCode_703_14.py.txt

@@ -0,0 +1,26 @@
+import heapq
+
+class KthLargest(object):
+
+    def __init__(self, k, nums):
+        """
+        :type k: int
+        :type nums: List[int]
+        """
+        self.nums = nums
+        self.k = k
+        heapq.heapify(self.nums)
+        while len(self.nums) > k:
+            heapq.heappop(self.nums)
+
+
+    def add(self, val):
+        if len(self.nums) < self.k:
+            heapq.heappush(self.nums, val)
+        elif val > self.nums[0]:
+            heapq.heapreplace(self.nums, val)
+        return self.nums[0]
+
+# Your KthLargest object will be instantiated and called as such:
+# obj = KthLargest(k, nums)
+# param_1 = obj.add(val)