2019-05-26

Author: JiayangWu

0072.编辑距离/0072-编辑距离.py

@@ -0,0 +1,25 @@
+class Solution(object):
+    def minDistance(self, word1, word2):
+        """
+        :type word1: str
+        :type word2: str
+        :rtype: int
+        """
+        #用dp[i][j]表示word1[:i + 1], word2[:j + 1]这个问题的解
+        m, n = len(word1), len(word2)
+        dp = [[0 for _ in range(n + 1)] for _ in range(m + 1)]
+        
+        for i in range(m + 1): 
+            dp[i][0] = i
+            
+        for i in range(n + 1):
+            dp[0][i] = i
+            
+        for i in range(1, m + 1):
+            for j in range(1, n + 1):
+                if word1[i - 1] == word2[j - 1]:
+                    dp[i][j] = dp[i - 1][j - 1]
+                else:
+                    dp[i][j] = 1 + min(dp[i - 1][j], dp[i - 1][j - 1], dp[i][j - 1]) #分别对应插入，替换，删除
+                    
+        return dp[m][n]

1051.高度检查器/1051-高度检查器.py

@@ -0,0 +1,14 @@
+class Solution(object):
+    def heightChecker(self, heights):
+        """
+        :type heights: List[int]
+        :rtype: int
+        """
+        h = sorted(heights)
+        # print h
+        res = 0
+        for i in range(len(heights)):
+            if h[i] != heights[i]:
+                res += 1
+        return res
+            

1052.爱生气的书店老板/1052-爱生气的书店老板.py

@@ -0,0 +1,45 @@
+class Solution(object):
+    def maxSatisfied(self, customers, grumpy, X):
+        """
+        :type customers: List[int]
+        :type grumpy: List[int]
+        :type X: int
+        :rtype: int
+        """
+        record = [0 for _ in range(len(grumpy))] #代表在i满意的顾客总数
+        s = 0
+        for i in range(len(grumpy)):
+            if grumpy[i] == 0:
+                record[i] += record[i - 1] + customers[i]
+            else:
+                record[i] += record[i - 1]
+                
+        print record       
+        tmp =  record[-1]#不生气的时候已经可以满足的
+
+        prefix = [0 for _ in range(len(grumpy))]
+        prefix[0] = customers[0]
+        
+        for i in range(1, len(grumpy)):
+            prefix[i] += prefix[i - 1] + customers[i]
+
+        lo, hi = 0, X - 1
+        newcus = 0
+        print prefix
+        while(hi < len(grumpy)):
+            if lo == 0:
+                presum = prefix[hi] - 0 #上了BUFF之后的
+                angsum = record[hi] - 0 #没上BUFF
+            else:
+                presum = prefix[hi] - prefix[lo - 1]
+                angsum = record[hi] - record[lo - 1]  
+            
+            earn = presum - angsum
+            print presum, angsum, earn, hi
+            newcus = max(presum - angsum, newcus)
+            hi += 1
+            lo += 1
+        return tmp + newcus
+            
+            
+                

1053.交换一次的先前排列/1053-交换一次的先前排列.py

@@ -0,0 +1,23 @@
+class Solution(object):
+    def prevPermOpt1(self, A):
+        """
+        :type A: List[int]
+        :rtype: List[int]
+        """
+        l = len(A)
+        if sorted(A) == A:
+            return A
+        
+        for i in range(l - 1, -1, -1): #保证在这一段递减
+            if A[i - 1] > A[i]: #找一个最大的数
+                break
+        #移动i - 1
+        print A[i - 1]
+        for j in range(l - 1, i - 1, -1): #找比A[i-1]小的最大的
+            if A[j] < A[i - 1]:
+                # j -= 1
+                break
+        print i, j
+        A[i - 1],A[j] = A[j],A[i - 1]
+        print A
+        return A

1054.距离相等的条形码/1054-距离相等的条形码.py

@@ -0,0 +1,34 @@
+class Solution(object):
+    def rearrangeBarcodes(self, barcodes):
+        """
+        :type barcodes: List[int]
+        :rtype: List[int]
+        """
+        from collections import Counter
+        import heapq
+        
+        record = Counter(barcodes) #统计每个数字出现的频率
+        
+        queue = []
+        for key, val in record.items():
+            queue.append([-val, key])
+            
+        heapq.heapify(queue) #建立优先级队列
+
+        res = []
+        pre = None
+        while queue or pre:
+            if queue:
+                cur = heapq.heappop(queue) #取出当前出现次数最多的元素，如果次数相同则先进先出
+                #frequency, value = cur[0], cur[1]
+                res.append(cur[1]) #把它放到答案里
+                cur[0] += 1 #给它的频率 - 1，因为Python支持最小堆，为了达到最大堆的效果，所以取了相反数操作
+                if cur[0] == 0: #这个元素已经放好了
+                    cur = None
+            else:
+                cur = None
+            if pre: #把前一个插入的数再进行入堆操作
+                heapq.heappush(queue, pre)
+            pre = cur #把这一轮的数用pre保存起来，此时这个数不在堆里，可以保障相邻元素不会重复
+                
+        return res