2019-5-21

Author: JiayangWu

0006.Z 字形变换/0006-Z 字形变换.py renamed to 0006.Z字形变换/0006-Z字形变换.py

@@ -4,12 +4,10 @@ def containsDuplicate(self, nums):
         :type nums: List[int]
         :rtype: bool
         """
-        record = dict()
-        for num in nums:
-            if record.get(num, 0):
+        if len(nums) <= 1:
+            return False
+        nums.sort()
+        for index in range(0,len(nums)-1):
+            if nums[index] == nums[index +1]:#or nums[index] == nums[index-1]:
                 return True
-            record[num] = 1
-        return False
-
-                
-        
+        return False

0008.字符串转换整数 (atoi)/0008-字符串转换整数 (atoi).py renamed to 0008.字符串转换整数(atoi)/0008-字符串转换整数(atoi).py

@@ -0,0 +1,17 @@
+class Solution(object):
+    def minCost(self, costs):
+        """
+        :type costs: List[List[int]]
+        :rtype: int
+        """
+        if not costs:
+            return 0
+        dp = costs
+        for i in range(1, len(costs)):
+            dp[i][0] += min(dp[i - 1][1], dp[i - 1][2])
+            dp[i][1] += min(dp[i - 1][0], dp[i - 1][2])
+            dp[i][2] += min(dp[i - 1][0], dp[i - 1][1])
+        return min(dp[-1])
+            
+                
+                

0040.组合总和 II/0040-组合总和 II.py renamed to 0040.组合总和II/0040-组合总和II.py

@@ -0,0 +1,11 @@
+class Solution(object):
+    def generatePossibleNextMoves(self, s):
+        """
+        :type s: str
+        :rtype: List[str]
+        """
+        res = []
+        for i in range(len(s) - 1):
+            if s[i:i+2] == "++":
+                res.append(s[:i] + "--" + s[i+2:])
+        return res

0047.全排列 II/0047-全排列 II.py renamed to 0047.全排列II/0047-全排列II.py

@@ -0,0 +1,55 @@
+# """
+# This is the interface that allows for creating nested lists.
+# You should not implement it, or speculate about its implementation
+# """
+#class NestedInteger(object):
+#    def __init__(self, value=None):
+#        """
+#        If value is not specified, initializes an empty list.
+#        Otherwise initializes a single integer equal to value.
+#        """
+#
+#    def isInteger(self):
+#        """
+#        @return True if this NestedInteger holds a single integer, rather than a nested list.
+#        :rtype bool
+#        """
+#
+#    def add(self, elem):
+#        """
+#        Set this NestedInteger to hold a nested list and adds a nested integer elem to it.
+#        :rtype void
+#        """
+#
+#    def setInteger(self, value):
+#        """
+#        Set this NestedInteger to hold a single integer equal to value.
+#        :rtype void
+#        """
+#
+#    def getInteger(self):
+#        """
+#        @return the single integer that this NestedInteger holds, if it holds a single integer
+#        Return None if this NestedInteger holds a nested list
+#        :rtype int
+#        """
+#
+#    def getList(self):
+#        """
+#        @return the nested list that this NestedInteger holds, if it holds a nested list
+#        Return None if this NestedInteger holds a single integer
+#        :rtype List[NestedInteger]
+#        """
+
+class Solution(object):
+    def depthSum(self, nestedList):
+        """
+        :type nestedList: List[NestedInteger]
+        :rtype: int
+        """
+        def Sum(weight, l):
+            if l.isInteger():
+                return weight * l.getInteger()
+            return sum(Sum(weight + 1, item) for item in l.getList())
+        
+        return sum(Sum(1, i) for i in nestedList)

0050.Pow(x, n)/0050-Pow(x, n).py renamed to 0050.Pow(x,n)/0050-Pow(x,n).py

@@ -0,0 +1,25 @@
+from collections import deque
+class MovingAverage(object):
+
+    def __init__(self, size):
+        """
+        Initialize your data structure here.
+        :type size: int
+        """
+        self.queue = deque()
+        self.Max_size = size
+
+    def next(self, val):
+        """
+        :type val: int
+        :rtype: float
+        """
+        self.queue.append(val)
+        if len(self.queue) > self.Max_size:
+            self.queue.popleft()
+        return 1.0 * sum(self.queue) / len(self.queue) 
+
+
+# Your MovingAverage object will be instantiated and called as such:
+# obj = MovingAverage(size)
+# param_1 = obj.next(val)

0052.N皇后 II/0052-N皇后 II.py renamed to 0052.N皇后II/0052-N皇后II.py

@@ -0,0 +1,43 @@
+class Solution(object):
+    def maxKilledEnemies(self, grid):
+        """
+        :type grid: List[List[str]]
+        :rtype: int
+        """
+        if not grid or not grid[0]:
+            return 0
+        m, n = len(grid), len(grid[0])
+        res = 0
+        def count(x0, y0):
+            cnt = 0
+            for x in range(x0, -1, -1): #ÏòÉÏ
+                if grid[x][y0] == "E":
+                    cnt += 1
+                elif grid[x][y0] == "W":
+                    break
+                    
+            for x in range(x0, m):  #ÏòÏÂ
+                if grid[x][y0] == "E":
+                    cnt += 1
+                elif grid[x][y0] == "W":
+                    break
+                    
+            for y in range(y0, -1, -1): #Ïò×ó
+                if grid[x0][y] == "E":
+                    cnt += 1
+                elif grid[x0][y] == "W":
+                    break      
+                     
+            for y in range(y0, n): #ÏòÓÒ
+                if grid[x0][y] == "E":
+                    cnt += 1
+                elif grid[x0][y] == "W":
+                    break   
+                    
+            return cnt
+            
+        for i in range(m):
+            for j in range(n):
+                if grid[i][j] == "0":
+                    res = max(res, count(i, j))
+        return res

0059.螺旋矩阵 II/0059-螺旋矩阵 II.py renamed to 0059.螺旋矩阵II/0059-螺旋矩阵II.py

@@ -0,0 +1,36 @@
+# Definition for singly-linked list.
+# class ListNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution(object):
+    def reverseList(self, head):
+        """
+        :type head: ListNode
+        :rtype: ListNode
+        """
+        if head is None or head.next is None:
+            return head
+        tmp = self.reverseList(head.next)
+        head.next.next = head
+        head.next = None
+        return tmp
+    
+    def plusOne(self, head):
+        """
+        :type head: ListNode
+        :rtype: ListNode 
+        """
+        head = self.reverseList(head)
+        tmp = head
+        head.val += 1
+        while(head.val > 9):
+            head.val -= 10
+            if head.next:
+                head.next.val += 1
+                head = head.next
+            else:
+                head.next = ListNode(1)
+                break
+        return self.reverseList(tmp)

0069.x 的平方根/0069-x 的平方根.py renamed to 0069.x的平方根/0069-x的平方根.py

@@ -0,0 +1,45 @@
+class PhoneDirectory(object):
+
+    def __init__(self, maxNumbers):
+        """
+        Initialize your data structure here
+        @param maxNumbers - The maximum numbers that can be stored in the phone directory.
+        :type maxNumbers: int
+        """
+        self.list = [0 for _ in range(maxNumbers)]
+        
+
+    def get(self):
+        """
+        Provide a number which is not assigned to anyone.
+        @return - Return an available number. Return -1 if none is available.
+        :rtype: int
+        """
+        for i, x in enumerate(self.list):
+            if x == 0:
+                self.list[i] = 1
+                return i
+        return -1
+
+    def check(self, number):
+        """
+        Check if a number is available or not.
+        :type number: int
+        :rtype: bool
+        """
+        return self.list[number] == 0
+
+    def release(self, number):
+        """
+        Recycle or release a number.
+        :type number: int
+        :rtype: None
+        """
+        self.list[number] = 0        
+
+
+# Your PhoneDirectory object will be instantiated and called as such:
+# obj = PhoneDirectory(maxNumbers)
+# param_1 = obj.get()
+# param_2 = obj.check(number)
+# obj.release(number)

0080.删除排序数组中的重复项 II/0080-删除排序数组中的重复项 II.py

@@ -0,0 +1,19 @@
+class Solution(object):
+    def calPoints(self, ops):
+        """
+        :type ops: List[str]
+        :rtype: int
+        """
+        stack = list()        
+        for i, op in enumerate(ops):
+            # print stack               
+            if op == "+":
+                stack.append(stack[-1] + stack[-2])
+            elif op == "D":
+                stack.append(2 * stack[-1])
+            elif op == "C":
+                stack.pop()
+            else:
+                stack.append(int(op))
+                
+        return sum(stack)