2019-06-16

Author: JiayangWu

1089.复写零/1089-复写零.py

@@ -0,0 +1,18 @@
+class Solution(object):
+    def duplicateZeros(self, arr):
+        """
+        :type arr: List[int]
+        :rtype: None Do not return anything, modify arr in-place instead.
+        """
+        l = len(arr)
+        i = 0
+        while i < l:
+            if arr[i] == 0:
+                for j in range(l - 1, i + 1, -1):
+                    arr[j] = arr[j - 1]
+                if i + 1 < l:
+                    arr[i + 1] = 0
+                i += 2
+            else:
+                i += 1
+        return arr

1090.受标签影响的最大值/1090-受标签影响的最大值.py

@@ -0,0 +1,27 @@
+from heapq import *
+class Solution(object):
+    def largestValsFromLabels(self, values, labels, num_wanted, use_limit):
+        """
+        :type values: List[int]
+        :type labels: List[int]
+        :type num_wanted: int
+        :type use_limit: int
+        :rtype: int
+        """
+        record = dict()
+        l = len(values)
+        for i in range(l):
+            if labels[i] not in record:
+                record[labels[i]] = [values[i]]
+                heapify(record[labels[i]])
+            else:
+                heappush(record[labels[i]], values[i])
+                if len(record[labels[i]]) > use_limit:
+                    heappop(record[labels[i]])
+                    
+        res = []
+        for key, val in record.items():
+            res += val
+        res.sort()
+        return sum(res[-num_wanted:])
+                    

1091.二进制矩阵中的最短路径/1091-二进制矩阵中的最短路径.py

@@ -0,0 +1,35 @@
+from collections import deque
+class Solution(object):
+    def shortestPathBinaryMatrix(self, grid):
+        """
+        :type grid: List[List[int]]
+        :rtype: int
+        """
+        n = len(grid)
+        # print n
+
+        if grid[0][0] or grid[-1][-1] == 1:
+            return -1
+        queue = deque([[[0, 0], 1]])
+        # queue2 = deque([[[n -1 , n - 1], 1]])
+        visited = set((0,0))
+        dx = [1, -1, 0, 0, 1, -1, -1, 1]
+        dy = [0, 0, 1, -1, -1, 1, -1, 1]
+        cnt = 1
+        record = dict()
+        while queue:
+            cur, cnt = queue.popleft()
+            # print cur, cnt
+            x0, y0 = cur[0], cur[1]
+            
+            if x0 == n - 1 and y0 == n - 1:
+                return cnt
+            for k in range(8):
+                x = x0 + dx[k]
+                y = y0 + dy[k]
+                
+                if 0 <= x <n and 0 <= y < n and grid[x][y] == 0 and (x, y) not in visited:
+                    visited.add((x, y))
+                    queue.append([[x, y], cnt + 1])
+        return -1
+        

1092.最短公共超序列/1092-最短公共超序列.py

@@ -0,0 +1,47 @@
+class Solution(object):
+    def shortestCommonSupersequence(self, str1, str2):
+        """
+        :type str1: str
+        :type str2: str
+        :rtype: str
+        """
+        #先找到最长公共子序列
+        l1, l2 = len(str1), len(str2)
+        if l1 < l2:
+            l1, l2 = l2, l1
+            str1, str2 = str2, str1
+        common = self.findLCS(str1, str2)  
+        # print common
+        res = ""
+        str1_idx = 0
+        str2_idx = 0
+        for char in common:
+            while str1_idx < l1 and str1[str1_idx] != char:
+                res += str1[str1_idx]
+                str1_idx += 1
+            while str2_idx < l2 and str2[str2_idx] != char:
+                res += str2[str2_idx]
+                str2_idx += 1
+            res += char
+            str1_idx += 1
+            str2_idx += 1
+            
+        if str1_idx != l1:
+            res += str1[str1_idx:]
+        if str2_idx != l2:
+            res += str2[str2_idx:]
+        return res
+
+    def findLCS(self, str1, str2):
+        m, n = len(str1), len(str2)
+        dp = [["" for _ in range(n + 1)] for _ in range(m + 1)]
+        for i in range(1, m + 1):
+            for j in range(1, n + 1):
+                if str1[i - 1] == str2[j - 1]: #匹配上了
+                    dp[i][j] = dp[i - 1][j - 1] + str1[i - 1]
+                elif len(dp[i - 1][j]) > len(dp[i][j - 1]):
+                    dp[i][j] = dp[i - 1][j]
+                elif len(dp[i - 1][j]) <= len(dp[i][j - 1]):
+                    dp[i][j] = dp[i][j - 1]
+
+        return dp[m][n]