【golang】leetcode中级-零钱兑换&最长上升子序列

wric

第一题 零钱兑换

题目

image.png

贪心(无效)

在日常的生活中 ,如果我们要进行零钱兑换,最朴素的思维自然是

如果可以使用更大面值的硬币,就优先选择它

这也正是贪心算法的思维

代码

func coinChange(coins []int, amount int) int {
    var res int
    sort.Ints(coins)
    if amount==0{return 0}
    for amount>=coins[0]{
        index:=sort.SearchInts(coins,amount)
        if index==len(coins){
            amount-=coins[len(coins)-1]
            res++
            continue
        }
        if coins[index]!=amount {
            amount-=coins[index-1]
        }else{
            amount-=coins[index]
        }
        res++
    }
    if amount!=0 {return -1}
    return res
}

该解法可以通过测试案例
image.png

但无法提交通过

image.png

原因是因为

题目提供的硬币组合不一定是日常中使用的硬币组合

大面值的硬币不一定是局部最优解

部分可以使用小面值组合组成的数字无法使用大面值表示

如果想要继续使用贪心算法,则需要加入回溯语句,排除使用大面值解的方案,再继续搜索

由于效率过低,在此不继续进行优化

后续优化思路可参考精选题解

https://leetcode-cn.com/probl...

动态规划

我们可以发现

寻找硬币组合的过程

本质上可以拆解成为一个一个挑选硬币的结果

例如:

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

动态规划的解题过程为实质为求解dp[11]的过程

在挑选第一个硬币时,有三种挑选的方案
挑选硬币1,硬币个数为dp[10]+1
挑选硬币2,硬币个数为dp[9]+1
挑选硬币5,硬币个数为dp[6]+1
在三个方案中选出个数最小的方案,即为dp[11]的解

因此可以得到
dp[amount]=min{dp[amount-coins[0],dp[amount-coins[1],...,dp[amount-coins[n-1]}+1

详细代码为

func coinChange(coins []int, amount int) int {
    //初始化数组,由于硬币为整型,挑选的硬币组合个数最大不可能大于面值amount
    max := amount + 1
    dp :=make([]int,max)
    for i:=range dp{
        dp[i]=max
    }
    dp[0] = 0

    for i := 1; i <max; i++ {
        for j := 0; j < len(coins); j++ {
            if coins[j] <= i {
            dp[i] = min(dp[i], dp[i - coins[j]] + 1)
            }
        }
    }

    if dp[amount]>amount {
        return -1
    }else{
        return dp[amount]
    }
}
func min(x int,y int)int{
    if x<y{
        return x
    }else {
        return y
    }
}

复杂度分析

时间复杂度:O(Sn),其中 S 是金额amount,n 是面额数len(coins)。我们一共需要计算 O(S) 个状态,S 为题目所给的总金额。对于每个状态,每次需要枚举 n 个面额来转移状态,所以一共需要 O(Sn) 的时间复杂度。
空间复杂度:O(S)。数组 dp 需要长度为总金额 S 的空间。

第二题 最长上升子序列

题目

image.png

思路

子序列的搜索过程显然具有最有子结构性质

对于i长度的序列

可以计算出以第一个元素为开始的前i-1个子序列的最优解

dp[i]的解即为所有满足递增的局部最优解中最长的一个加一

代码

func lengthOfLIS(nums []int) int {
    if len(nums) == 0 {
        return 0
    }
    dp := make([]int, len(nums))
    dp[0] = 1
    maxans := 1
    for i := 1; i < len(nums); i++ {
        dp[i] = 1
        for j := 0; j < i; j++ {
            if nums[i] > nums[j] {
                dp[i] = max(dp[i], dp[j]+1)
            }
        }
        maxans = max(maxans, dp[i])
    }
    return maxans
}
func max(x int,y int)int{
    if x>y{
        return x
    }else{
        return y
    }
}

复杂度分析

时间复杂度:O(n^2),其中 n 为数组 nums 的长度。动态规划的状态数为 n,计算状态 dp[i] 时,需要 O(n) 的时间遍历 dp[0…i−1] 的所有状态,所以总时间复杂度为 O(n^2)

空间复杂度:O(n),需要额外使用长度为 n 的 dp 数组。

优化-贪心+二分

参考官解
https://leetcode-cn.com/probl...
思路与算法

考虑一个简单的贪心,如果我们要使上升子序列尽可能的长,则我们需要让序列上升得尽可能慢,因此我们希望每次在上升子序列最后加上的那个数尽可能的小。

基于上面的贪心思路,我们维护一个数组 d[i] ,表示长度为 i 的最长上升子序列的末尾元素的最小值,用 l 记录目前最长上升子序列的长度,起始时 l 为 1,d[1]=nums[0]。

同时我们可以注意到 d[i] 是关于 i 单调递增的。因为如果d[j]≥d[i] 且 j<i,我们考虑从长度为 i 的最长上升子序列的末尾删除 i−j 个元素,那么这个序列长度变为 j ,且第 j 个元素 x(末尾元素)必然小于 d[i],也就小于 d[j]。那么我们就找到了一个长度为 j 的最长上升子序列,并且末尾元素比 d[j] 小,从而产生了矛盾。因此数组 d 的单调性得证。

我们依次遍历数组 nums 中的每个元素,并更新数组 d 和 l 的值。如果 nums[i]>d[len] 则更新 len=len+1,否则在 d[1…len]中找满足 d[i−1]<nums[j]<d[i] 的下标 i,并更新 d[i]=nums[j]。

根据 d 数组的单调性,我们可以使用二分查找寻找下标 i,优化时间复杂度。

最后整个算法流程为:

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

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

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

以输入序列 [0, 8, 4, 12, 2] 为例:

第一步插入 0,d = [0];

第二步插入 8,d = [0, 8]

第三步插入 4,d = [0, 4]

第四步插入 12,d = [0, 4, 12]

第五步插入 2,d = [0, 2, 12]

最终得到最大递增子序列长度为 3。

代码

func lengthOfLIS(nums []int) int {
    l := 1
    n := len(nums)
    if n == 0 {
        return 0
    }
    d:=make([]int,n+1)
    d[l] = nums[0]
    for i := 1; i < n; i++ {
        if nums[i] > d[l] {
            l++
            d[l] = nums[i]
        } else {
            ll := 1
            rr := l
            pos := 0 // 如果找不到说明所有的数都比 nums[i] 大,此时要更新 d[1],所以这里将 pos 设为 0
            for ll <= rr {
                mid := (ll + rr) >> 1
                if d[mid] < nums[i] {
                    pos = mid
                    ll = mid + 1
                } else {
                    rr = mid - 1
                }
            }
            d[pos + 1] = nums[i]
        }
    }
    return l
}

复杂度分析

时间复杂度:O(nlogn)。数组 nums 的长度为 n,我们依次用数组中的元素去更新 d 数组,而更新 d 数组时需要进行 O(logn) 的二分搜索,所以总时间复杂度为 O(nlogn)。

空间复杂度:O(n),需要额外使用长度为 n 的 d 数组。

阅读 556
10 声望
3 粉丝
0 条评论
10 声望
3 粉丝
文章目录
宣传栏