leetcode-python 第四周

LeetCode Online Judge
https://leetcode.com/

LeetCode题解
https://github.com/soulmachine/leetcode

1.The Best To Buy and Sell Stock II [60ms]

#方法1：后来经过测试，题目是可以当天卖出然后当天再买入的
#这样问题就可以化解为贪心
#例如[1, 2, 5, 6], 画个数轴就知道了
class Solution(object):
    def maxProfit(self, prices):
        ans = 0
        for i in range(len(prices)-1):
            if prices[i+1] - prices[i] > 0:
                ans += prices[i+1] - prices[i]
        return ans

2.Find Minimum in Rotated Sorted Array II[48ms]

#方法1：二分搜索，如果其中一边是正序的话，取最左边的数
#再去另外一边看有没有比这个数更小的
class Solution(object):
    def findMin(self, nums):
        ans = 100000
        low = 0
        high = len(nums)
        while low != high :
            mid = int((low+high) / 2)
            if nums[low] < nums[mid] :
                ans = min(nums[low], ans)
                low = mid + 1
            else:
                ans = min(nums[mid], ans)
                high = mid
        return ans

3.Find Peek Element [52ms]

#方法1：注意题目是找到任意一个就可以而且左右元素不相等。
#比较n次，最大的元素一定是波峰 [52ms]
#方法2：二分查找，如果中间是上升则往右边找。[56ms]
class Solution(object):
    def findPeakElement(self, nums):
        ans = 0
        for i in range(1, len(nums)):
            if nums[i] >= nums[i-1]:
                ans = i
        return ans

class Solution(object):
    def findPeakElement(self, nums):
        low, high = 0, len(nums)-1
        while low <= high :
            if low == high :
                return low
            mid = (int(low+high) / 2)
            if nums[mid] < nums[mid+1] :
                low = mid + 1
            else :
                high = mid

4.Minimum Size Subarray Sum [65ms]

#方法1：自己写的滑窗，因为不用一头一尾的while循环，
#所以需要额外判断的条件比较多
#方法2：二分枚举，[96ms]
class Solution(object):
    def minSubArrayLen(self, s, nums) :
        low = 0
        addup = 0
        ans = 100000

        for i in range(len(nums)):
            addup += nums[i]

            if addup >= s :
                ans = min(ans, i-low+1)

            while addup >= s and addup - nums[low] >= s :
                addup -= nums[low]
                low += 1
                ans = min(ans, i-low+1)
        if addup >= s:
            ans = min(ans, len(nums)-low)

        if ans == 100000 :
            return 0
        return ans

class Solution:
  def minSubArrayLen(self, s, nums):
    size = len(nums)
    left, right = 0, size
    bestAns = size + 1
    while left <= right:
      mid = int((left + right) / 2)
      if self.solve(mid, s, nums):
        bestAns = mid #bestAns也代表窗口大小，随二分不断试试减少
        right = mid - 1
      else:
        left = mid + 1
    return [0, bestAns][bestAns <= size]
  def solve(self, l, s, nums):
    sums = 0
    for x in range(len(nums)):
      sums += nums[x]
      if x >= l:
        sums -= nums[x - l] #窗口滑动
      if sums >= s:
        return True
    return False

5.Subset [108ms]

class Solution(object):
    import copy
    def subsets(self, nums):
        result = []
        tmp = []
        self.dfs(0, tmp, result, nums)
        return result

    def dfs(self, k, tmp, result, nums) :
        r = copy.deepcopy(tmp)
        result.append(r)
        for i in range(k, len(nums)) :
            tmp.append(nums[i])
            self.dfs(i+1, tmp, result, nums)
            del tmp[-1]
        return 

6.Subset II [124ms]

#方法1:例子[1, 2, 2]
class Solution(object):
    import copy

    def dfs(self, k, tmp, result, nums) :
        r = copy.deepcopy(tmp)
        result.append(r)
        for i in range(k, len(nums)) :
            #防止重复
            if i > k and nums[i] == nums[i-1] :
                continue
            tmp.append(nums[i])
            self.dfs(i+1, tmp, result, nums)
            del tmp[-1]
        return

    def subsetsWithDup(self, nums) :
        result = []
        tmp = []
        nums.sort()
        self.dfs(0, tmp, result, nums)
        return result

7.Triangle [54ms]

#方法1：动态规划的思想，从下往上，改变三角形的数
#取下面两个接邻数的最小
# f[i][j] = min(f[i+1][j], f[i+1][j+1]) + f[i][j]
class Solution(object):
    def minimumTotal(self, triangle):
        for i in range(len(triangle)-2, -1, -1) :
            for j in range(i+1) :
                triangle[i][j] = min(triangle[i+1][j], triangle[i+1][j+1]) + triangle[i][j]
        return triangle[0][0]