[25]零钱兑换和最长递增子序列

*内容来自leetcode

1.零钱兑换

题目要求

给你一个整数数组 coins ，表示不同面额的硬币；以及一个整数 amount ，表示总金额。

计算并返回可以凑成总金额所需的 最少的硬币个数 。如果没有任何一种硬币组合能组成总金额，返回 -1 。

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

示例 1：

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

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

思路

这道题其实跟[23]中的跳跃游戏类似，本质就是选择不同的步数来到达终点。此外，这道题要求步子尽可能的大，也就是步数要尽可能的小。

最初的想法是，一直叠加最大的，如果超过了sum，则开始叠加第二大的，以此类推。这样的问题在于只有在最大的硬币数为最多的情况时才能得到正确。

以下是官方的思路，基于动态规划的思想，有如下式

F(S)=F(S−C)+1

那么就有递归和循环两种办法来解决。

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

class Solution:
    def coinChange(self, coins: List[int], amount: int) -> int:
        @functools.lru_cache(amount)
        def findNum(amount):
            if amount == 0:return 0
            if amount < 0 : return -1 
            mini = int(1e9)
            for coin in self.coins:
                res = findNum(amount-coin)
                if res >= 0 and res < mini:
                    mini = res + 1
            return mini if mini < int(1e9) else -1
        self.coins = coins
        if amount < 1:return 0
        return findNum(amount)

2.最长递增子序列

题目要求

给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。

子序列 是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。
示例 1：

输入：nums = [10,9,2,5,3,7,101,18]
输出：4
解释：最长递增子序列是 [2,3,7,101]，因此长度为 4 。
示例 2：

输入：nums = [0,1,0,3,2,3]
输出：4

思路

所有的动态规划的思路都是以之前的状态为基础进行递推的，就需要找到合适的状态转移方程。

动态规划

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

贪心+二分

整个算法流程为：

设当前已求出的最长上升子序列的长度为 len（初始时为 1），从前往后遍历数组 nums，在遍历到 nums[i]时：

如果 nums[i]>d[len]，则直接加入到 d 数组末尾，并更新 len=len+1；

否则，在 d 数组中二分查找，找到第一个比 nums[i]小的数 d[k]，并更新 d[k+1]=nums[i]。

class Solution:
    def lengthOfLIS(self, nums: List[int]) -> int:
        #贪心+二分
        res = [nums[0]]
        for i in range(1,len(nums)):
            if nums[i] > res[-1]:
                res.append(nums[i])
            else:
                left = 0
                right = len(res)-1
                loc = right
                while left <= right:
                    mid = (left + right) // 2
                    if res[mid] >= nums[i]:
                        loc = mid
                        right = mid - 1
                    else:
                        left = mid + 1
                res[loc] = nums[i]

        return len(res)