动态规划DP小记1

53:最大子序和
给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

示例:
输入: [-2,1,-3,4,-1,2,1,-5,4],
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/maximum-subarray
cur:当前最大子序和
res:以当前数字结尾的前面所有子序列的最大和
如果cur<=0,说明对最大和无增益，应该从当前数字开始重新计算

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        cur=0
        res=nums[0]
        for i in range(len(nums)):
            if cur<=0:
                cur=nums[i]
            else:
                cur+=nums[i]
            res=max(cur,res)
        return res

70.爬楼梯
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
dp[i]=dp[i-1]+dp[i-2]

class Solution:
    def climbStairs(self, n: int) -> int:
        if n < 3:
            return n
        dp = [0] * (n+1)
        dp[1] = 1
        dp[2] = 2
        for i in range(3, n+1):
            dp[i] = dp[i-1] + dp[i-2]
        return dp[-1]

121 股票问题
dp[i]=前 I 天的最大利润
minprice:前面i天的最低价格
price[i]-minprice:i当天卖了股票所获得最大利润
dp[i]=max(dp[i-1],price[i]-minprice)

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        if not prices:
            return 0
        minprice=prices[0]
        dp=[0]*len(prices)
        for i in range(len(prices)):
            minprice=min(minprice,prices[i])
            dp[i]=max(dp[i-1],prices[i]-minprice)
        return dp[-1]

122 买卖股票最佳时期2
只要今天比昨天价格高，卖了就是赚了，
状态转移方程：
dp[i] = dp[i-1] if prices[i]<=prices[i-1] else dp[i-1]+(prices[i]-prices[i-1])
如果今天比昨天价更高，则dp[i] = dp[i-1]+高出的价格；反之，则不变

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        # dp[i] = dp[i-1] if prices[i]<=prices[i-1] else dp[i-1]+(prices[i]-prices[i-1])
        res=0
        for i in range(1,len(prices)):
        	if prices[i]>prices[i-1]:
        		res+=prices[i]-prices[i-1]
        return res

198 打家劫舍
dp[i]:到第i个房子时所能拿到的最大金额
因为不能相邻，所以从第I-2个房子过来才可以拿到第i个房子的钱
dp[i]=max(dp[i-2]+nums[i],dp[i-1])

class Solution:
    def rob(self, nums: List[int]) -> int:
        dp=[0]*len(nums)
        if not nums:
            return 0
        if len(nums)==1:
            return nums[0]
        if len(nums)==2:
            return max(nums[0],nums[1])
        dp[0]=nums[0]
        dp[1]=max(nums[0],nums[1])
        for i in range(2,len(nums)):
            dp[i]=max(dp[i-2]+nums[i],dp[i-1])
        return dp[-1]

303:给定一个整数数组 nums，求出数组从索引 i 到 j (i ≤ j) 范围内元素的总和，包含 i, j 两点。

示例：

给定 nums = [-2, 0, 3, -5, 2, -1]，求和函数为 sumRange()

sumRange(0, 2) -> 1
sumRange(2, 5) -> -1
sumRange(0, 5) -> -3

来源：力扣（LeetCode）

dp[i]:为第i个元素前面所有元素之和（不包括第i个元素）

class NumArray:

    def __init__(self, nums: List[int]):
        if(not nums):
            return 
        n=len(nums)
        self.dp=[0]*(n+1)
        self.dp[1]=nums[0]
        for i in range(2,n+1):
            self.dp[i]=nums[i-1]+self.dp[i-1]

    def sumRange(self, i: int, j: int) -> int:
        return self.dp[j+1]-self.dp[i]

746使用最小花费爬楼梯
dp[i]:爬到第i个台阶所需要最低体力花费
dp[i]=min(dp[i-1],dp[i-2])+cost[i]

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