代码随想录day52｜子序列系列｜300.最长递增子序列｜674. 最长连续递增序列｜718. 最长重复子数组｜Golang

编程练习时长两年半

已于 2022-11-12 00:48:54 修改

阅读量372

点赞数

分类专栏：代码随想录训练营｜算法基础文章标签：算法动态规划

于 2022-11-11 16:34:35 首次发布

本文链接：https://blog.csdn.net/weixin_42161901/article/details/127806182

版权

代码随想录训练营｜算法基础专栏收录该内容

63 篇文章 9 订阅

订阅专栏

代码随想录day52

加油，时间不多了

300.最长递增子序列

思路

最长上升子序列是动规的经典题目，这里dp[i]是可以根据dp[j] （j < i）推导出来的，那么依然用动规五部曲来分析详细一波：

1、dp[i]的定义

dp[i]表示i之前包括i的以nums[i]结尾的最长上升子序列的长度。

2、状态转移方程

位置i都最长升序子序列等于j从0～i-1各个位置的最长升序自序列+1的最大值。

所以：if nums[i] > nums[j] {

dp[i] = max(dp[i], dp[j]+1)

}

注意这里不是要dp[i]与dp[j]+1进行比较，而是我们要取dp[j]+1的最大值。

3、dp[i]的初始化

每一个i，对应的dp[i] ，起始大小至少都是1。即最长上升子序列最少是1。

4、确定遍历顺序

dp[i]是由0～i-1各个位置的最长升序子序列推导而来，那么遍历i一定是从前向后遍历。j其实就是0～i-1，遍历i到循环在外层，遍历j则在内层，代码如下：

for (int i = 1; i < nums.size(); i++) {
    for (int j = 0; j < i; j++) {
        if (nums[i] > nums[j]) dp[i] = max(dp[i], dp[j] + 1);
    }
    if (dp[i] > result) result = dp[i]; // 取长的子序列
}

5、举例推导dp数组

输入：[0,1,0,3,2]，dp数组的变化如下：

如果代码写出来，但一直AC不了，那么就把dp数组打印出来，看看对不对！

以上五部分析完毕，Go代码如下：

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

func max(a, b int) int {
    if a > b {
        return a 
    }
    return b
}

总结

本题最关键的是要想到dp[i]由哪些状态可以推出来，并取最大值，那么很自然就能想到递推公式：dp[i] = max(dp[i], dp[j] + 1);

子序列问题是动态规划的一个重要系列，本题算是入门题目，好戏刚刚开始！

674. 最长连续递增序列

思路

本题相对于昨天的动态规划：300.最长递增子序列最大的区别在于“连续”。

本题要求的是最长连续递增序列

动态规划

动规五部曲分析如下：

1、确定dp数组（dp table）以及下标的含义

dp[i]：以下标i为结尾的数组的连续递增的子序列长度为dp[i]。

注意这里的定义，一定是以下标i为结尾，并不是说一定以下标0为起始位置。

2、确定递推公式

如果 nums[i + 1] > nums[i]，那么以 i+1 为结尾的数组的连续递增的子序列长度一定等于以i为结尾的数组的连续递增的子序列长度 + 1 。

即：dp[i + 1] = dp[i] + 1;

注意这里就体现出和动态规划：300.最长递增子序列的区别！动态规划：300.最长递增子序列

因为本题要求连续递增子序列，所以就必要比较nums[i + 1]与nums[i]，而不用去比较nums[j]与nums[i] （j是在0到i之间遍历）。

既然不用j了，那么也不用两层for循环，本题一层for循环就行，比较nums[i + 1] 和 nums[i]。

这里大家要好好体会一下！

3、dp数组如何初始化

以下标i为结尾的数组的连续递增的子序列长度最少也应该是1，即就是nums[i]这一个元素。

所以dp[i]应该初始1;

4、确定遍历顺序

从递推公式上可以看出， dp[i + 1]依赖dp[i]，所以一定是从前向后遍历。

本文在确定递推公式的时候也说明了为什么本题只需要一层for循环，代码如下：

for (int i = 0; i < nums.size() - 1; i++) {
    if (nums[i + 1] > nums[i]) { // 连续记录
        dp[i + 1] = dp[i] + 1; // 递推公式
    }
}

5、举例推导dp数组

已输入nums = [1,3,5,4,7]为例，dp数组状态如下：

注意这里要取dp[i]里的最大值，所以dp[2]才是结果！

以上分析完毕，Go代码如下：

func findLengthOfLCIS(nums []int) int {
    dp := make([]int, len(nums))
    for i:=0;i<len(nums);i++{
        dp[i] = 1
    }
    ans := 1
    for i:=0;i<len(nums)-1;i++{
        if nums[i+1] > nums[i] {
            dp[i+1] = dp[i] + 1 
        } 
        if dp[i+1] > ans {
            ans = dp[i+1]
        }
    }
    return ans
}

总结

本题也是动规里子序列问题的经典题目，但也可以用贪心来做，大家也会发现贪心好像更简单一点，而且空间复杂度仅是O(1)。

在动规分析中，关键是要理解和动态规划：300.最长递增子序列的区别。动态规划：300.最长递增子序列

要联动起来，才能理解递增子序列怎么求，递增连续子序列又要怎么求。

概括来说：不连续递增子序列的跟前0-i 个状态有关，连续递增的子序列只跟前一个状态有关

本篇我也把区别所在之处重点介绍了，关键在递推公式和遍历方法上，大家可以仔细体会一波！

718. 最长重复子数组

思路

记住，子序列默认不连续，子数组默认连续

注意题目中说的子数组，其实就是连续子序列。这种问题动规最拿手，动规五部曲分析如下：

1、确定dp数组（dp table）以及下标的含义

2、确定递推公式

3、dp数组如何初始化

4、确定遍历顺序

5、举例推导dp数组

拿示例1中，A: [1,2,3,2,1]，B: [3,2,1,4,7]为例，画一个dp数组的状态变化，如下：

以上五部曲分析完毕，Go代码如下：

func findLength(A []int, B []int) int {
	m, n := len(A), len(B)
	res := 0
	dp := make([][]int, m+1)
	for i := 0; i <= m; i++ { 
		dp[i] = make([]int, n+1)
	}

	for i := 1; i <= m; i++ {
		for j := 1; j <= n; j++ {
			if A[i-1] == B[j-1] {
				dp[i][j] = dp[i-1][j-1] + 1
			}
			if dp[i][j] > res {
				res = dp[i][j]
			}
		}
	}
	return res
}

只能说这一题完全不懂，待补充学习吧，今天头晕了。