python 动态规划算法

"""
1.确定状态
假设最优解为K a1+a2+...+ak
1.1 最后一步：假设最优解为 27 - ak
1.2 子问题： 求27-ak最优解f(x) ---> [f[x-2] +1、 f[x-5] +1、 f[x-7] +1]

2. 转移方程式：f(27) = min(f[25] +1, f[22] +1, f[20] +1)

3.初始条件 f(0) = 0

4.计算顺序 0->27

"""


def test(A, x):
    # 设置每个值得默认值为无穷大
    f = [float("inf") for i in range(x+1)]
    # 设置初始值
    f[0] = 0
    # 计算1到x每个值的最小步骤
    for i in range(1, x+1):
        # 求解A中列举的各种解决方案获得最优解
        for j in A:
            if i >= j:
                f[i] = min(f[i - j] + 1, f[i])
    print(f[x])


test([2, 5, 7], 27)

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

示例:

输入: [-2,1,-3,4,-1,2,1,-5,4]
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。

"""
1 确定状态：
最优解为以下标i为结束点的连续子数组和最大
1.1 假设列表为nums, 最后一个数组下标为i, 最优解为函数f, 最后一步为求出最后一个结束点的连续子数组和最大
1.2 子问题求解f[i-1]的最优解
2 转移方程式：
f[k] = max(a[k], f[k-1]+a[k])
3 初始条件：
f[0] = a[0]
4 计算顺序
a[0] --> a[k]
"""

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        f = [float("-inf") for _ in range(len(nums))]
        f[0] = nums[0]
        for i in range(1, len(f)):
            f[i] = max(nums[i], f[i-1] + nums[i])
        f.sort()
        return f[-1]

简化版本

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        for i in range(1, len(nums)):
            nums[i] = max(nums[i], nums[i-1] + nums[i])
        nums.sort()
        return nums[-1]

力扣300. 最长上升子序列

给定一个无序的整数数组，找到其中最长上升子序列的长度。

示例:
输入: [10,9,2,5,3,7,101,18]
输出: 4
解释: 最长的上升子序列是 [2,3,7,101]，它的长度是 4。

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

        return max(dp)