动态规划

动态规划问题

三要素：

最优子结构：子问题的最优解能够决定这个问题的最优解

边界：问题最小子集的解(初始范围)

状态转移函数：递推式

1爬楼梯

分析:
        假定n=10,首先考虑最后一步的情况,要么从第九级台阶再走一级到第十级,要么从第八级台阶走两级到第十级,因而,要想到达第十级台阶,最后一步一定是从第八级或者第九级台阶开始.也就是说已知从地面到第八级台阶一共有X种走法,从地面到第九级台阶一共有Y种走法,那么从地面到第十级台阶一共有X+Y种走法.
即F(10)=F(9)+F(8)
     分析到这里,动态规划的三要素出来了.
        边界:F(1)=1,F(2)=2
        最优子结构:F(10)的最优子结构即F(9)和F(8)
        状态转移函数:F(n)=F(n-1)+F(n-2)

class Solution(object):
    def climbStairs(self, n):
        if n <= 2:
            return n
        a = 1
        b = 2
        for i in range(3, n+1):
            a, b = b, a+b
        return  b

2 最大子序和

给定一个整数数组nums, 找到一个具有最大和的连续子数组，返回其最大和。

分析：
最优子序列：当前值的最大子序和是(之前最大子序和+当前值，当前值)
边界：第一个值的最大子序和是它自身
状态转移函数：dp[i]=max(nums[i], nums[i]+dp[i-1])

nums = [-2,1,-3,4,-1,2,1,-5,4]
dp = [-2, 1, -2, 4, 3, 5, 6, 1, 5]

class Solution(object):
    def maxSubArray(self, nums):
        if  len(nums)==0:
            return 0
        # 定义一个表格用于存储上一个问题的最优解
        d = []
        d.append(nums[0])
        max_num = nums[0]
        for i in range(1, len(nums)):
            if nums[i]>nums[i]+d[i-1]:
                d.append(nums[i])
            else:
                d.append(nums[i]+d[i-1])
            if max_num < d[i]:
                max_num = d[i]
        # return max(d)
        return max_num

打家劫舍

最优子结构：最后一家偷不偷，偷则加上前两位的最大值，不偷则是前一位的最大值
边界：d[0]=nums[0], d[1]=max(nums[0], nums[1])
状态转移函数:d[i]=max(d[i-1], d[i-2]+nums[i])

class Solution(object):
    def rob(self, nums):
        if len(nums)==0:
            return 0
        if len(nums)<=2:
            return max(nums)
        dp = []
        dp.append(nums[0])
        dp.append(max(nums[0], nums[1]))
        for i in range(2, len(nums)):
            dp.append(max(dp[i-1], dp[i-2]+nums[i]))
        return dp[-1]

买股票的最佳时机

[7,1,5,3,6,4]
最优子结构：f(1)的最优子结构是f(7)
边界:f(0)=0
递推式：f(1) = max(f(7), 4-最小金额)
其中最小金额是在变化的

class Solution(object):
    def maxProfit(self, prices):
        if len(prices)<=1:
            return 0
        dp = []
        dp.append(0)
        min_value=prices[0]
        for i in range(1, len(prices)):
            dp.append(max(dp[i-1], prices[i]-min_value))
            if prices[i]<min_value:
                min_value=prices[i]
        return dp[-1]

使用最小话费爬楼梯

最优子结构：f(9)和f(8)
边界：f(0)=1, f(1)=100
递推式：f(10)=min(f(9)+cost(9), f(8)+cost(8))

class Solution(object):
    def minCostClimbingStairs(self, cost):
        if len(cost) <= 1:
            return min(cost)
        dp = []
        dp.append(cost[0])
        dp.append(cost[1])
        for i in range(2, len(cost)+1):
            if i==len(cost):
                dp.append(min(dp[i-1], dp[i-2]))
            else:
                dp.append(min(dp[i-1]+cost[i], dp[i-2]+cost[i]))
        return dp[-1]