动态规划 零钱兑换-最长上升子序列

这个算法一直不太会，再加上现在最近考试和项目比较多，所以就耽搁下来了，现在来梳理一下

1.找出最优解性质，并刻化其结构特征（最优子结构）
2.递归定义最优值
3.以自底向上方式计算最优值
4.根据计算最优值时信息，构造最优解

看看这个就入门了
输入格式：

5      //表示三角形的行数    接下来输入三角形

7

3   8

8   1   0

2   7   4   4

4   5   2   6   5

要求输出最大和

接下来，我们来分析一下解题思路：

首先，肯定得用二维数组来存放数字三角形

然后我们用D( r, j) 来表示第r行第 j 个数字(r,j从1开始算)

我们用MaxSum(r, j)表示从D(r,j)到底边的各条路径中，最佳路径的数字之和。

因此，此题的最终问题就变成了求 MaxSum(1,1)

当我们看到这个题目的时候，首先想到的就是可以用简单的递归来解题：

D(r, j)出发，下一步只能走D(r+1,j)或者D(r+1, j+1)。故对于N行的三角形，我们可以写出如下的递归式： 

if ( r == N)                
	MaxSum(r,j) = D(r,j)  
else      
	MaxSum( r, j) = Max{ MaxSum(r＋1,j), MaxSum(r+1,j+1) } + D(r,j) 

float(“inf”)是正无穷

给定不同面额的硬币 coins 和一个总金额 amount。编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1。

零钱兑换：

示例 1:

输入: coins = [1, 2, 5], amount = 11
输出: 3 
解释: 11 = 5 + 5 + 1
示例 2:

输入: coins = [2], amount = 3
输出: -1
 

说明:
你可以认为每种硬币的数量是无限的。

class Solution:
    def coinChange(self, coins: List[int], amount: int) -> int:
        coids = coins.sort()
        dp=[0]
        for i in range(1,amount+1):
            dp.append(float('inf'))
            for coin in coins:
                if i>=coin:
                    if dp[i-coin]+1<dp[i]:
                        dp[i]=dp[i-coin]+1
                else:
                    break
        return dp[-1] if dp[-1]!=float('inf') else -1

方法二：

class Solution:
    def coinChange(self, coins: List[int], amount: int) -> int:
        dp = [float('inf')] * (amount + 1)
        dp[0] = 0
        
        for coin in coins:
            for x in range(coin, amount + 1):
                dp[x] = min(dp[x], dp[x - coin] + 1)
        return dp[amount] if dp[amount] != float('inf') else -1

最长上升子序列

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

示例:

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

说明:

可能会有多种最长上升子序列的组合，你只需要输出对应的长度即可。
你算法的时间复杂度应该为 O(n2) 。

#暴力动态规划
class Solution:
    def lengthOfLIS(self, nums: List[int]) -> int:
        if not nums:
            return 0
        dp = []
        for i in range(len(nums)):
            dp.append(1)
            for j in range(i):
                if nums[i] > nums[j]:
                    dp[i] = max(dp[i], dp[j] + 1)
        return max(dp)

作者：LeetCode-Solution

class Solution:
    def lengthOfLIS(self, nums: List[int]) -> int:
        #动态规划+二分
        if not nums:
            return 0
        if len(nums)==1:
            return 1
        nums_list = [nums[0]]
        for i in range(1,len(nums)):
            if nums[i]>nums_list[-1]:
                nums_list.append(nums[i])
            else:
                left,right = 0,len(nums_list)-1
                while left<=right:
                    mid = (left+right)//2
                    if nums_list[mid]>=nums[i]:
                        right = mid-1
                    elif nums_list[mid]<nums[i]:
                        left = mid+1
                nums_list[left]=nums[i]
        return len(nums_list)