力扣 动态规划 Python

1.除数博弈

class Solution(object):
    def divisorGame(self, N):
        """
        :type N: int
        :rtype: bool
        """
        if N % 2 != 0:
            return False
        else:
            return True

2.最大子序和

class Solution(object):
    def maxSubArray(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        tmp = 0
        maxnum = nums[0]
        for i in range(len(nums)):
            tmp += nums[i]
            maxnum = max(tmp, maxnum)
            if tmp < 0:
                tmp = 0
        return maxnum

class Solution(object):
    def maxSubArray(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        for i in range(1,len(nums)):
            tmp = max(nums[i]+nums[i-1],nums[i])
            nums[i] = tmp
        return max(nums)

3.按摩师

class Solution(object):
    def massage(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        if len(nums) == 0:
            return 0
        dp0, dp1 = 0, nums[0]
        for i in range(1, len(nums)):
            tdp0 = max(dp0, dp1)
            tdp1 = dp0 + nums[i]
            dp0, dp1 = tdp0, tdp1
        return max(dp0, dp1)           

4.买卖股票的最佳时机

class Solution(object):
    def maxProfit(self, prices):
        """
        :type prices: List[int]
        :rtype: int
        """
        minprice = int(1e9)
        maxprofit = 0
        for price in prices:
            maxprofit = max(price - minprice, maxprofit)
            minprice = min(price, minprice)
        return maxprofit

5.打家劫舍

class Solution(object):
    def rob(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        if len(nums) == 0:
            return 0
        
        dp0 = 0
        dp1 = nums[0]
        for i in range(1,len(nums)):
            tdp0 = max(dp0, dp1)
            tdp1 = dp0 + nums[i]
            dp0, dp1 = tdp0, tdp1
        return max(dp0, dp1)

6.使用最小话费爬楼梯

class Solution(object):
    def minCostClimbingStairs(self, cost):
        """
        :type cost: List[int]
        :rtype: int
        """
        dp = [0] * (len(cost)+1)
        for i in range(2,len(cost)+1):
            dp[i] = min(dp[i-1] + cost[i-1], dp[i-2] + cost[i-2])
        return dp[len(cost)]

7.连续子数组的最大和

class Solution(object):
    def maxSubArray(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        thesum = 0
        submax = nums[0]
        for i in range(len(nums)):
            thesum += nums[i]
            submax = max(submax, thesum)
            if thesum < 0:
                thesum = 0
        return submax

8.区域和检索-数组不可变

class NumArray(object):

    def __init__(self, nums):
        """
        :type nums: List[int]
        """
        self.nums = nums


    def sumRange(self, i, j):
        """
        :type i: int
        :type j: int
        :rtype: int
        """
        thesum = 0
        for idx in range(i,j + 1):
            thesum += self.nums[idx]
        return thesum
        


# Your NumArray object will be instantiated and called as such:
# obj = NumArray(nums)
# param_1 = obj.sumRange(i,j)

9.三步问题

class Solution(object):
    def waysToStep(self, n):
        """
        :type n: int
        :rtype: int
        """
        if n == 1:
            return 1
        if n ==2:
            return 2
        if n ==  3:
            return 4
        if n > 3:
            return (self.waysToStep(n-1) + self.waysToStep(n-2) + self.waysToStep(n-3)) % 1000000007
（超时）

class Solution(object):
    def waysToStep(self, n):
        """
        :type n: int
        :rtype: int
        """
        if n == 1:
            return 1
        if n ==2:
            return 2
        tmp1, tmp2, tmp3 = 1, 2, 4
        for i in range(3, n):
            tmp1, tmp2, tmp3 = tmp2, tmp3, tmp1 + tmp2 + tmp3
            tmp1 %= 1000000007
            tmp2 %= 1000000007
            tmp3 %= 1000000007
        return tmp3

10.爬楼梯

class Solution(object):
    def climbStairs(self, n):
        """
        :type n: int
        :rtype: int
        """
        if n == 1:
            return 1
        if n == 2:
            return 2
        tmp1, tmp2 = 1, 2
        for i in range(2, n):
            tmp1, tmp2 = tmp2, tmp1 + tmp2
        return tmp2

11.连续数列

class Solution(object):
    def maxSubArray(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        for i in range(1,len(nums)):
            tmp = max(nums[i] + nums[i - 1], nums[i])
            nums[i] = tmp
        return max(nums)

12.判断子序列

class Solution(object):
    def isSubsequence(self, s, t):
        """
        :type s: str
        :type t: str
        :rtype: bool
        """
        i, j = 0, 0
        len_s = len(s)
        len_t = len(t)
        while i < len_s and j < len_t:
            if s[i] == t[j]:
                i += 1
            j += 1
        return i==len_s

13.一和零

class Solution(object):
    def findMaxForm(self, strs, m, n):
        """
        :type strs: List[str]
        :type m: int
        :type n: int
        :rtype: int
        """
        dp = [[0] * (n + 1) for _ in range(m + 1)]

        for str in strs:
            zeros, ones = str.count('0'), str.count('1')
            for i in range(m, zeros - 1, -1):
                for j in range(n, ones - 1, -1):
                    dp[i][j] = max(dp[i][j], dp[i - zeros][j - ones] + 1)
        return dp[m][n]

14.最长上升子序列

class Solution(object):
    def lengthOfLIS(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        dp = [1] * len(nums)
        for i in range(len(nums)):
            for j in range(i):
                if nums[i] > nums[j]:
                    dp[i] = max(dp[i], dp[j] + 1)
        return max(dp)

15.最长湍流子数组

class Solution(object):
    def maxTurbulenceSize(self, arr):
        """
        :type arr: List[int]
        :rtype: int
        """
        if len(arr) == 1:
            return 1
        dp = [[1] * 2 for _ in range(len(arr))]
        result = 0
        for i in range(1, len(arr)):
            if arr[i - 1] < arr[i]:
                dp[i][1] = dp[i - 1][0] + 1
            if arr[i - 1] > arr[i]:
                dp[i][0] = dp[i - 1][1] + 1
            result = max(result, max(dp[i]))
        return result

16.K站中转内最便宜的航班

class Solution(object):
    def findCheapestPrice(self, n, flights, src, dst, K):
        """
        :type n: int
        :type flights: List[List[int]]
        :type src: int
        :type dst: int
        :type K: int
        :rtype: int
        """
        dist = [[float("inf")] * n for _ in range(2)]
        dist[0][src] = dist[1][src] = 0
        for i in xrange(K + 1):
            for u, v, w in flights:
                dist[i & 1][v] = min(dist[i & 1][v], dist[~ i & 1][u] + w)
        return dist[K & 1][dst] if dist[K & 1][dst] < float("inf") else -1

17.

class Solution(object):
    def new21Game(self, N, K, W):
        """
        :type N: int
        :type K: int
        :type W: int
        :rtype: float
        """
        if K == 0:
            return 1.0
        dp =[0.0] * (K + W)
        for i in range(K, min(N, K + W - 1) + 1):
            dp[i] = 1.0
        dp[K - 1] = float(min(N - K + 1, W)) / W
        for i in range(K - 2, -1, -1):
                dp[i] = dp[i + 1] - (dp[i + W + 1] - dp[i + 1]) / W
        return dp[0]

class Solution(object):
    def new21Game(self, N, K, W):
        """
        :type N: int
        :type K: int
        :type W: int
        :rtype: float
        """
        dp = [0.0] * (K + W)
        s = 0
        for i in range(K, K + W):
            dp[i] = 1 if i <= N else 0
            s += dp[i]
        for i in range(K-1, -1, -1):
            dp[i] = float(s)/W
            s = s - dp[i + W] + dp[i]
        return dp[0]

18.统计字典序元音字符串的数目

class Solution(object):
    def countVowelStrings(self, n):
        """
        :type n: int
        :rtype: int
        """
        dp = [[0] * 5 for _ in range(n + 1)]
        dp[1][0] = 1
        dp[1][1] = 2
        dp[1][2] = 3
        dp[1][3] = 4
        dp[1][4] = 5
        for i in range(2, n + 1):
            for j in range(0,5):
                if j == 0:
                    dp[i][j] = dp[i - 1][j]
                else:
                    dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
        return dp[n][4]

19.剪绳子 II

class Solution(object):
    def cuttingRope(self, n):
        """
        :type n: int
        :rtype: int
        """
        if n <= 3:
            return n - 1
        a, b, p = n // 3, n % 3, 1000000007
        if b == 0:
            return 3 ** a % p
        elif b == 1:
            return 3 ** (a - 1) * 4 % p
        else:
            return 3 ** a * 2 % p