2020-07-01

Author: JiayangWu

1.两数之和/1-两数之和.py

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

102.二叉树的层序遍历/102-二叉树的层序遍历.py

@@ -0,0 +1,31 @@
+# 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 levelOrder(self, root):
+        """
+        :type root: TreeNode
+        :rtype: List[List[int]]
+        """
+        if not root:
+            return []
+        queue = [root]
+        res = list()
+        while queue:
+            nextqueue = list()
+            layer = list()
+            for node in queue:
+                if node.left:
+                    nextqueue.append(node.left)
+                if node.right:
+                    nextqueue.append(node.right)
+                layer.append(node.val)
+                
+            queue = nextqueue[:]
+            res.append(layer)
+        return res
+        

11.盛最多水的容器/11-盛最多水的容器.py

@@ -0,0 +1,20 @@
+class Solution(object):
+    def maxArea(self, height):
+        """
+        :type height: List[int]
+        :rtype: int
+        """
+        lo, hi = 0, len(height) - 1
+        res = 0
+        while(lo < hi):
+            if height[lo] > height[hi]:
+                area = height[hi] * (hi - lo)
+                hi -= 1
+            else:
+                area = height[lo] * (hi - lo)
+                lo += 1
+            # print area
+            res = max(area, res)
+            
+        return res
+                

1150.检查一个数是否在数组中占绝大多数/1150-检查一个数是否在数组中占绝大多数.py

@@ -5,4 +5,4 @@ def isMajorityElement(self, nums, target):
         :type target: int
         :rtype: bool
         """
-        return nums.count(target) > len(nums) // 2
+        return nums.count(target) > (len(nums) // 2)

116.填充每个节点的下一个右侧节点指针/116-填充每个节点的下一个右侧节点指针.py

@@ -0,0 +1,36 @@
+"""
+# Definition for a Node.
+class Node(object):
+    def __init__(self, val=0, left=None, right=None, next=None):
+        self.val = val
+        self.left = left
+        self.right = right
+        self.next = next
+"""
+class Solution(object):
+    def connect(self, root):
+        """
+        :type root: Node
+        :rtype: Node
+        """
+        if not root or not root.left:
+            return root
+
+        root.left.next = root.right
+        if root.next:
+            root.right.next = root.next.left
+        self.connect(root.left)
+        self.connect(root.right)
+        
+        return root
+    
+    def findNext(self, node):
+        nxt = node.next
+        while nxt:
+            if nxt.left:
+                return nxt.left
+            elif nxt.right:
+                return nxt.right
+            else:
+                nxt = nxt.next
+        return None

117.填充每个节点的下一个右侧节点指针II/117-填充每个节点的下一个右侧节点指针II.py

@@ -0,0 +1,41 @@
+"""
+# Definition for a Node.
+class Node(object):
+    def __init__(self, val=0, left=None, right=None, next=None):
+        self.val = val
+        self.left = left
+        self.right = right
+        self.next = next
+"""
+class Solution(object):
+    def connect(self, root):
+        """
+        :type root: Node
+        :rtype: Node
+        """
+        if not root:
+            return root
+        
+        if root.left and root.right:
+            root.left.next = root.right
+            root.right.next = self.findNext(root)
+        
+        elif root.left:
+            root.left.next = self.findNext(root)
+        elif root.right:
+            root.right.next = self.findNext(root)
+            
+        self.connect(root.right)
+        self.connect(root.left)
+        
+        return root
+    
+    def findNext(self, node):
+        nxt = node.next
+        while nxt:
+            if nxt.left:
+                return nxt.left
+            if nxt.right:
+                return nxt.right
+            nxt = nxt.next
+        return None

1170.比较字符串最小字母出现频次/1170-比较字符串最小字母出现频次.py

@@ -5,24 +5,18 @@ def numSmallerByFrequency(self, queries, words):
         :type words: List[str]
         :rtype: List[int]
         """
+        def f(word):
+            return word.count(min(word))
 
-        def func(word):
-            for char in "abcdefghijklmnopqrstuvwxyz":
-                if char in word:
-                    return word.count(char)
-            return 0
+        f_words = sorted([f(word) for word in words])
 
-        def func2(word):
-            record = collections.Counter(word)
-            return record[min(record.keys())]
-        
-        
-        words_count = sorted(map(func2, words))
-        queries_count = map(func2, queries)
-        # print words_count, queries_count
-        ans = []
-        for query in queries_count:
-            index = bisect.bisect(words_count, query) #bisect可以迅速找出有index个数 <= query
-            ans.append(len(words_count) - index)# 减法找有多少个数比query大
-        return ans
+        res = []
+        # print f_words
+        for q in queries:
+            cnt = f(q)
+            # print(bisect.bisect(f_words, cnt))
+            res.append(len(f_words) - bisect.bisect(f_words, cnt))
+            
+        return res
+            
 

1209.删除字符串中的所有相邻重复项II/1209-删除字符串中的所有相邻重复项II.py

@@ -0,0 +1,20 @@
+class Solution(object):
+    def removeDuplicates(self, s, k):
+        """
+        :type s: str
+        :type k: int
+        :rtype: str
+        """
+        stack = []
+        for ch in s:
+            if not stack:
+                stack.append([ch, 1])
+            else:
+                if stack[-1][0] == ch:
+                    stack[-1][1] += 1
+                    if stack[-1][1] % k == 0:
+                        stack.pop()
+                else:
+                    stack.append([ch, 1])
+
+        return "".join(ch * freq for ch, freq in stack)

121.买卖股票的最佳时机/121-买卖股票的最佳时机.py

@@ -0,0 +1,12 @@
+class Solution(object):
+    def maxProfit(self, prices):
+        """
+        :type prices: List[int]
+        :rtype: int
+        """
+        res = 0
+        pre_min = prices[0] if prices else 0
+        for price in prices:
+            res = max(res, price - pre_min)
+            pre_min = min(pre_min, price)
+        return res

1219.黄金矿工/1219-黄金矿工.py

@@ -0,0 +1,31 @@
+class Solution(object):
+    def getMaximumGold(self, grid):
+        """
+        :type grid: List[List[int]]
+        :rtype: int
+        """
+        dx = [1, -1, 0, 0]
+        dy = [0, 0, 1, -1]
+        m, n = len(grid), len(grid[0])
+        visited = set()
+        self.res = 0
+        
+        def dfs(x0, y0, tmp):
+            self.res = max(self.res, tmp)
+            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] > 0:
+                    value = grid[x][y]
+                    grid[x][y] = -1
+                    dfs(x, y, tmp + value)
+                    grid[x][y] = value
+                    
+        for i in range(m):
+            for j in range(n):
+                value = grid[i][j]
+                grid[i][j] = -1
+                dfs(i, j, value)
+                grid[i][j] = value
+        return self.res