2019-5-22

Author: JiayangWu

0033.搜索旋转排序数组/0033-搜索旋转排序数组.py

@@ -0,0 +1,43 @@
+class Solution(object):
+    def search(self, nums, target):
+        """
+        :type nums: List[int]
+        :type target: int
+        :rtype: int
+        """
+        if not nums:
+            return -1
+        if len(nums) == 1:
+            return 0 if nums[0] == target else -1
+        
+        lo, hi = 0, len(nums) - 1
+        while(lo <= hi):
+            mid = (lo + hi) // 2
+            # print mid, nums[mid]
+            if mid + 1 < len(nums) and nums[mid] > nums[mid +1]:
+                break
+            if nums[mid] < nums[-1]:
+                hi = mid - 1
+            elif nums[mid] >= nums[0]:
+                lo = mid + 1
+                
+        if lo > hi:#ĂťÓĐĐýת
+            lo, hi = 0, len(nums) - 1
+        else:
+            if target >= nums[0]:
+                lo, hi = 0, mid
+            else:
+                lo, hi = mid + 1, len(nums) - 1
+
+        while(lo <= hi):
+            # print lo, hi
+            mid = (lo + hi) // 2
+            if nums[mid] == target:
+                return mid
+            elif nums[mid] > target:
+                hi = mid - 1
+            else:
+                lo = mid + 1
+        
+        return -1
+                

0034.在排序数组中查找元素的第一个和最后一个位置/0034-在排序数组中查找元素的第一个和最后一个位置.py

@@ -0,0 +1,48 @@
+class Solution(object):
+    def searchRange(self, nums, target):
+        """
+        :type nums: List[int]
+        :type target: int
+        :rtype: List[int]
+        """
+        lo, hi = 0, len(nums) - 1
+        #找第一个target
+        while(lo <= hi):
+            mid = (lo + hi) // 2
+            if nums[mid] == target:
+                break
+            elif nums[mid] > target:
+                hi = mid - 1
+            else:
+                lo = mid + 1
+        if lo > hi: #不存在
+            return [-1, -1]
+
+        midtarget = mid
+        lo, hi = 0, mid
+        leftpos = 0
+        while(lo <= hi):
+            # print lo, hi
+            if (hi >= 1 and nums[hi - 1] != target) or hi == 0: #找到左边界或者找到头了
+                leftpos = hi
+                break
+            mid = (lo + hi) // 2
+            if nums[mid] == target:
+                hi = mid
+            elif nums[mid] < target:
+                lo = mid + 1
+
+        rightpos = 0
+        lo, hi = midtarget, len(nums) - 1
+        while(lo <= hi):
+            if (lo <= len(nums) - 2 and nums[lo + 1] != target) or lo == len(nums) - 1: #找到右边界或者找到头了
+                rightpos = lo
+                break
+            mid = (lo + hi + 1) // 2
+            if nums[mid] == target:
+                lo = mid 
+            elif nums[mid] > target:
+                hi = mid - 1
+                
+        return [leftpos, rightpos]
+                

0057.插入区间/0057-插入区间.py

@@ -0,0 +1,42 @@
+# Definition for an interval.
+# class Interval(object):
+#     def __init__(self, s=0, e=0):
+#         self.start = s
+#         self.end = e
+
+class Solution(object):
+    def insert(self, intervals, newInterval):
+        """
+        :type intervals: List[Interval]
+        :type newInterval: Interval
+        :rtype: List[Interval]
+        """
+        # tmp = Interval(newInterval[0], newInterval[1])
+        intervals.append(newInterval)
+        # intervals[-1] = newInterval
+        # print type(intervals[0]), type(tmp)
+        return self.merge(intervals)
+    
+    def merge(self, intervals):
+        """
+        :type intervals: List[Interval]
+        :rtype: List[Interval]
+        """
+        
+        if not intervals:
+            return []
+        intervals = sorted(intervals,key=lambda x:x[0])
+        res = []
+        left = intervals[0][0]
+        right = intervals[0][1]
+        for item in intervals:
+            if item[0] <= right:
+                right = max(right, item[1])
+            else:
+                res.append([left, right])
+                left = item[0]
+                right = item[1]
+        res.append([left, right])
+                
+        return res
+            

0060.第k个排列/0060-第k个排列.py

@@ -0,0 +1,18 @@
+import math
+class Solution(object):
+    def getPermutation(self, n, k):
+        """
+        :type n: int
+        :type k: int
+        :rtype: str
+        """
+        digit = [i for i in range(1, n + 1)] #生成1 ~ n的列表
+        res = ""
+        while n > 0:
+            tmp = math.factorial(n - 1) #计算一共有多少种组合
+            idx =  (k - 1) / tmp #由K在tmp中占的比例来确定第一位的数字
+            k -= idx * tmp #第一位确定之后，刷新k
+            res += str(digit[idx])
+            digit.pop(idx)
+            n -= 1
+        return res

0092.反转链表II/0092-反转链表II.py

@@ -0,0 +1,63 @@
+# Definition for singly-linked list.
+# class ListNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution(object):
+    def reverseBetween(self, head, m, n):
+        """
+        :type head: ListNode
+        :type m: int
+        :type n: int
+        :rtype: ListNode
+        """
+        # 先找到m ~ n这一段，翻转，再塞回去
+        if m == n:
+            return head
+        cnt = 1
+        pre_m, pn = None, None
+        node = head
+        while(cnt < n):
+            # print node.val, cnt
+            if cnt == m - 1:
+                pre_m = node
+            node, cnt = node.next, cnt + 1
+        pn = node
+        if pn:
+            nextn = pn.next
+            pn.next = None
+        else:
+            nextn = None
+        # print pre_m.val, nextn.val
+         
+        if pre_m is None: #从1开始
+            head = self.reverseList(head)
+            newhead = head
+            while(head.next):
+                head = head.next
+            head.next = nextn
+            return newhead
+        else:
+            pre_m.next = self.reverseList(pre_m.next)
+            newhead = head
+            while(head.next):
+                head = head.next
+            head.next = nextn
+            return newhead
+        
+            
+            
+
+        
+    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

0265.粉刷房子II/0265-粉刷房子II.py

@@ -0,0 +1,23 @@
+class Solution(object):
+    def minCostII(self, costs):
+        """
+        :type costs: List[List[int]]
+        :rtype: int
+        """
+        if not costs or not costs[0]:
+            return 0
+        dp = costs
+        
+        def GetMin(idx, k):
+            Min = max(costs[idx])
+            for i, cost in enumerate(costs[idx]):
+                if i == k:
+                    continue
+                Min = min(Min, cost)
+            return Min
+        
+        for i in range(1, len(costs)):
+            for k in range(len(costs[i])):
+                dp[i][k] += GetMin(i - 1, k)
+        return min(dp[-1])
+            

0531.孤独像素I/0531-孤独像素I.py

@@ -0,0 +1,25 @@
+class Solution(object):
+    def findLonelyPixel(self, picture):
+        """
+        :type picture: List[List[str]]
+        :rtype: int
+        """
+        if not picture or not picture[0]:
+            return 0
+        m, n = len(picture), len(picture[0])
+        res = 0
+        
+        def check(x0, y0):      
+            for x in range(0, m):  #ͬһÁÐ
+                if picture[x][y0] == "B" and x != x0:
+                    return False
+            for y in range(0, n): #ͬһÐÐ
+                if picture[x0][y] == "B" and y != y0:
+                    return False
+            return True
+        
+        for i in range(m):
+            for j in range(n):
+                if picture[i][j] == "B" and check(i, j):
+                    res += 1
+        return res