【算法篇】逐步理解动态规划模型5（子序列问题）
目录
子数组问题
1.最长递增子序列
2.最长递增子序列
3.最长等差数列
本文旨在通过对力扣上三道题进行讲解来让大家对使用动态规划解决多状态有一定思路，培养大家对状态定义，以及状态方程书写的思维。
顺序：
题目链接-》算法思路-》代码呈现
子数组问题
动态规划类题目解题步骤：
- 依据题目进行状态表示(dp[i]的含义)
- 写出状态转移方程(类似于dp[i]=dp[i-1]+dp[i-2])
- 为防止填表时数组越界，对dp表进行初始化（dp[0]=dp[1]=1）
- 搞清楚填表顺序（从前往后或者从后往前）
- 利用dp表返回问题答案
1.最长递增子序列
题目链接：
https://leetcode.cn/problems/longest-increasing-subsequence/description/
算法思路：
1. 状态表⽰：
对于线性 dp ，我们可以⽤「经验 + 题⽬要求」来定义状态表⽰：
- 以某个位置为结尾，巴拉巴拉；
- 以某个位置为起点，巴拉巴拉。
这⾥我们选择⽐较常⽤的⽅式，以某个位置为结尾，结合题⽬要求，定义⼀个状态表⽰：
dp[i] 表示：以 i 位置元素为结尾的「所有⼦序列」中，最⻓递增⼦序列的⻓度。
2. 状态转移⽅程：
对于 dp[i] ，我们可以根据「⼦序列的构成⽅式」，进⾏分类讨论：
- 子序列⻓度为 1 ：只能⾃⼰玩了，此时 dp[i] = 1 ；
- 子序列⻓度⼤于 1 ： nums[i] 可以跟在前⾯任何⼀个数后⾯形成⼦序列。 设前面的某⼀个数的下标为 j ，其中 0 <= j <= i - 1 。 只要 nums[j] < nums[i] ， i 位置元素跟在 j 元素后⾯就可以形成递增序列，⻓度为 dp[j] + 1 。 因此，我们仅需找到满⾜要求的最大的 dp[j] + 1 即可。
综上， dp[i] = max(dp[j] + 1, dp[i]) ，其中 0 <= j <= i - 1 && nums[j]
< nums[i] 。
3. 初始化：
所有的元素「单独」都能构成⼀个递增⼦序列，因此可以将 dp 表内所有元素初始化为 1 。
由于⽤到前⾯的状态，因此我们循环的时候从第⼆个位置开始即可。
4. 填表顺序：
显⽽易⻅，填表顺序「从左往右」。
5. 返回值：
由于不知道最⻓递增⼦序列以谁结尾，因此返回 dp 表⾥⾯的「最⼤值」。
代码呈现：
class Solution {public int lengthOfLIS(int[] nums) {int n=nums.length;int re=1;int[] dp=new int[n];dp[0]=1;for(int i=1;i<n;i++){dp[i]=1;for(int j=0;j<i;j++){if(nums[i]>nums[j]) dp[i]=Math.max(dp[i],dp[j]+1); }re=re>dp[i]?re:dp[i];}return re;}
}2.最长递增子序列
题目链接：
https://leetcode.cn/problems/number-of-longest-increasing-subsequence/description/
算法思路：
1. 状态表⽰：
先尝试定义⼀个状态：以 i 为结尾的最⻓递增⼦序列的「个数」。那么问题就来了，我都不知道
以 i 为结尾的最⻓递增⼦序列的「⻓度」是多少，我怎么知道最⻓递增⼦序列的个数呢？
因此，我们解决这个问题需要两个状态，⼀个是「⻓度」，⼀个是「个数」：
len[i] 表示：以 i 为结尾的最⻓递增⼦序列的长度；
count[i] 表示：以 i 为结尾的最⻓递增⼦序列的个数。
2. 状态转移方程：
求个数之前，我们得先知道⻓度，因此先看 len[i] ：
- 在求 i 结尾的最⻓递增序列的⻓度时，我们已经知道 [0, i - 1] 区间上的 len[j] 信息，用 j 表示 [0, i - 1] 区间上的下标；
- 我们需要的是递增序列，因此 [0, i - 1] 区间上的 nums[j] 只要能和 nums[i] 构成上升序列，那么就可以更新 dp[i] 的值，此时最长长度为 dp[j] + 1；
- 我们要的是 [0, i - 1] 区间上所有情况下的最大值。
综上所述，对于 len[i] ，我们可以得到状态转移⽅程为：
len[i] = max(len[j] + 1, len[i]) ，其中 0 <= j < i ，并且 nums[j] < nums[i] 。
在知道每⼀个位置结尾的最⻓递增⼦序列的⻓度时，我们来看看能否得到 count[i] ：
- 我们此时已经知道 len[i] 的信息，还知道 [0, i - 1] 区间上的 count[j] 信息，⽤ j 表⽰ [0, i - 1] 区间上的下标；
- 我们可以再遍历⼀遍 [0, i - 1] 区间上的所有元素，只要能够构成上升序列，并且上升序列的⻓度等于 dp[i] ，那么我们就把 count[i] 加上 count[j] 的值。这样循环⼀遍之后， count[i] 存的就是我们想要的值。
综上所述，对于 count[i] ，我们可以得到状态转移⽅程为：
count[i] += count[j] ，其中 0 <= j < i ，并且 nums[j] < nums[i] &&
dp[j] + 1 == dp[i] 。
3. 初始化：
- 对于 len[i] ，所有元素⾃⼰就能构成⼀个上升序列，直接全部初始化为 1 ；
- 对于 count[i] ，如果全部初始化为 1 ，在累加的时候可能会把「不是最⼤⻓度的情况」累加进去，因此，我们可以先初始化为 0 ，然后在累加的时候判断⼀下即可。具体操作情况看代码~
4. 填表顺序：
毫⽆疑问是「从左往右」。
5. 返回值：
⽤ manLen 表⽰最终的最⻓递增⼦序列的⻓度。
根据题⽬要求，我们应该返回所有⻓度等于 maxLen 的⼦序列的个数。
代码呈现：
class Solution {public int findNumberOfLIS(int[] nums) {int n=nums.length;int[] len=new int[n];int[] count=new int[n];for(int k=0;k<n;k++){len[k]=1;count[k]=1;}int retlen=1,retcount=0;for(int i=0;i<n;i++){for(int j=0;j<i;j++){if(nums[i]>nums[j]){if(len[j]+1==len[i]){count[i]+=count[j];}else if(len[j]+1>len[i]){len[i]=len[j]+1;count[i]=count[j];}}}if(retlen==len[i]){retcount+=count[i];}else if(retlen<len[i]){retlen=len[i];retcount=count[i];}}return retcount;}
}3.最长等差数列
题目链接：
https://leetcode.cn/problems/longest-arithmetic-subsequence/description/
算法思路：
1. 状态表⽰：
对于线性 dp ，我们可以⽤「经验 + 题⽬要求」来定义状态表示：
- 以某个位置为结尾，巴拉巴拉；
- 以某个位置为起点，巴拉巴拉。
这⾥我们选择⽐较常⽤的⽅式，以某个位置为结尾，结合题⽬要求，定义⼀个状态表⽰：
dp[i] 表⽰：以 i 位置元素为结尾的「所有⼦序列」中，最⻓的等差序列的⻓度。
但是这⾥有⼀个⾮常致命的问题，那就是我们⽆法确定 i 结尾的等差序列的样子。这样就会导致我们⽆法推导状态转移方程，因此我们定义的状态表⽰需要能够确定⼀个等差序列。
根据等差序列的特性，我们仅需知道序列里面的最后两个元素，就可以确定这个序列的样⼦。因此，我们修改我们的状态表示为：
dp[i][j] 表示：以 i 位置以及 j 位置的元素为结尾的所有的⼦序列中，最⻓的等差序列的⻓度。规定⼀下 i < j 。
2. 状态转移方程：
设 nums[i] = b, nums[j] = c ，那么这个序列的前⼀个元素就是 a = 2 * b - c 。我们
根据 a 的情况讨论：
- a 存在，下标为 k ，并且 a < b ：此时我们需要以 k 位置以及 i 位置元素为结尾的最长等差序列的⻓度，然后再加上 j 位置的元素即可。于是 dp[i][j] = dp[k][i] + 1 。这⾥因为会有许多个 k ，我们仅需离 i 最近的 k 即可。因此任何最⻓的都可以以 k为结尾；
- a 存在，但是 b < a < c ：此时只能两个元素⾃⼰玩了， dp[i][j] = 2 ；
- a 不存在：此时依旧只能两个元素⾃⼰玩了， dp[i][j] = 2 。
综上，状态转移⽅程分情况讨论即可。
优化点：我们发现，在状态转移⽅程中，我们需要确定 a 元素的下标。因此我们可以将所有的元素 + 下标绑定在⼀起，放到哈希表中，这⾥有两种策略：
- 在 dp 之前，放⼊哈希表中。这是可以的，但是需要将下标形成⼀个数组放进哈希表中。这样时间复杂度较高，我帮⼤家试过了，超时。
- ⼀边 dp ，⼀边保存。这种方式，我们仅需保存最近的元素的下标，不⽤保存下标数组。但是用这种方法的话，我们在遍历顺序那⾥，先固定倒数第⼆个数，再遍历倒数第⼀个数。这样就可以在 i 使⽤完时候，将 nums[i] 扔到哈希表中。
3. 初始化：
根据实际情况，可以将所有位置初始化为 2 。
4. 填表顺序：
- 先固定倒数第⼆个数；
- 然后枚举倒数第⼀个数。
5. 返回值：
由于不知道最长的结尾在哪⾥，因此返回 dp 表中的最⼤值。
代码呈现：
class Solution {public int longestArithSeqLength(int[] nums) {int n=nums.length;Map<Integer,Integer> hash=new HashMap<>();int[][] dp=new int[n][n];for(int i=0;i<n;i++){for(int j=0;j<n;j++){dp[i][j]=2;}}for(int i=0;i<n;i++){for(int j=i+1;j<n;j++){int x=2*nums[i]-nums[j];if(hash.getOrDefault(x,-1)>=0&&hash.getOrDefault(x,-1)<i){dp[i][j]=dp[hash.get(x)][i]+1;}}hash.put(nums[i],i);}int max=0;for(int i=0;i<n;i++){for(int j=0;j<n;j++){max=max<dp[i][j]?dp[i][j]:max;}}return max;}
}