二刷力扣——DP算法（子序列问题）

300. 最长递增子序列

定义是以本元素结尾，所以公式初始化都好弄。但是太慢

class Solution {public int lengthOfLIS(int[] nums) {int n=nums.length;int[] dp = new int[n];//以自己结尾的最长递增子序列dp[0]=1;int maxzi=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);} maxzi=Math.max(maxzi,dp[i]);}return maxzi;}
}

时间O（n^2），空间O（n）

看题解的优化：

贪心+二分查找：

下面链接说的很清楚：

https://writings.sh/post/longest-increasing-subsequence-revisited

中心思想是：

所以这里的d数组定义是：d[i]是长度为 i 的递增子序列的最小结尾元素。比如d[2]=6，所以长度为2 的递增子序列里面，结尾元素最小的情况是2。

所以挨个遍历nums数组来更新这个d数组，注意这个d数组是动态的，不像之前动态规划的DP数组，我们得记录他的长度，因为遇到了nums某元素比d最后的结尾还大，就要把这个某元素加入到d数组，扩大d数组。。如果遇到某元素比结尾小，对应d数组定义，那d数组里面肯定有某个值要更新为这个nums[i]，这个值是哪个位置？就是把比nums[i]大的&最接近nums[i]的换成nums[i]。举例下图。遇到3比d 的结尾8要小，所以更新d 的某个元素，找到比3大的&最接近3 的元素是6，so替换。这样保证d[2]=3，对应长度为2的递增子序列的最小结尾元素是3（2、3这个子序列）。

所以在过程中，d数组长度不会减少，所以p数组装的nums元素的个数，就是所要求的最长递增子序列长度，d数组的最后结尾元素代表了一条递增最慢的子序列，所以这个元素的下标，也就是len就是结果。

还有一个解释：

代码注意，没有写==的时候break，所以退出循环一定是left=right+2了，这个时候left的位置就是比nums[i]大的&最接近nums[i]的位置，然后直接替换成nums[i]。

len是为了记录包含nums元素的个数，因为这里没有使用大小可动态变化的集合。

class Solution {public int lengthOfLIS(int[] nums) {int n=nums.length;if(n==0)return 0;int len =1;int[] d = new int[n+1];//长度为i的递增子序列的最小结尾元素d[len]=nums[0];for(int i=1;i<n;++i){if(nums[i]>d[len])//加到结尾去{d[++len]=nums[i];}else//在d[1]-d[len]中找到更改为nums[i]后使得d仍然有序的位置；二分查找更快{int l=1,r=len;//左闭右闭while(l<=r){int mid=(l+r)>>1;if(d[mid]<nums[i]){l=mid+1;}else r=mid-1;}d[l]=nums[i];//替换}}return len;}
}

贪心遍历nums，动态规划遍历dp，给固定大小的数组的每个元素求解值。

674. 最长连续递增序列

可以DP数组，也可以贪心省存储。

贪心：用start记录连续子序列的开头下标，发现连续递增在i 这里断了，就更新start为i（重新一个递增序列）。然后取最大值

class Solution {public int findLengthOfLCIS(int[] nums) {int n=nums.length,maxCount=1;int start=0;for(int i=1;i<n;++i){if(nums[i]<=nums[i-1]){start=i;}maxCount=Math.max(maxCount,i-start+1);}return maxCount; }
}

718. 最长重复子数组

dp[i][j]：如果不想单独初始化的话，dp设置比nums偏移一个坐标，是以nums1[i-1]和nums2[j-1]结尾的子数组最长长度；不偏移的话是nums1[i]和nums2[j]结尾的子数组最长长度

公式：如果遍历的两个元素相等，可以在上一个dp[i-1][j-1]的基础上拼接这个元素，所以+1

偏移：

class Solution {public int findLength(int[] nums1, int[] nums2) {int m=nums1.length,n=nums2.length;int[][] dp=new int[m+1][n+1];//以nums1[i-1]和nums2[j-1]结尾的子数组最长 长度int maxCount=0;for(int i=1;i<=m;++i){for(int j=1;j<=n;++j){if(nums2[j-1]==nums1[i-1]){dp[i][j]=dp[i-1][j-1]+1;maxCount=Math.max(dp[i][j],maxCount);}}}return maxCount;}
}

还可以用滚动数组实现，注意跟 01背包的滚动数组实现一样，留下的那个维度只能在内循环，而且得从大到小，因为得是上一轮的值而不是这一轮更新过的值。

而且不相等的时候，要把dp[j]清零，因为二维的时候不操作dp[i][[j]直接就是0；但是一维的时候不操作是继承了上一轮的值，是错的。只要不相等以nums1[i-1]结尾的子数组长度就是0，所以置零。

class Solution {public int findLength(int[] nums1, int[] nums2) {int m=nums1.length,n=nums2.length;int[] dp=new int[m+1];//以nums1[i-1] 结尾的子数组最长 长度int maxCount=0;for(int i=1;i<=n;++i){for(int j=m;j>=1;--j)//留下维度从大到小{if(nums2[i-1]==nums1[j-1]){dp[j]=dp[j-1]+1;maxCount=Math.max(dp[j],maxCount);}else dp[j]=0;   //不相等了，清零}}return maxCount;}
}

不偏移：

class Solution {public int findLength(int[] nums1, int[] nums2) {int m=nums1.length,n=nums2.length;int[][] dp=new int[m ][n ];//nums1[i]和nums2[j]结尾的子数组最长 长度int maxCount=0;for(int i=0;i<n;++i){dp[0][i]=nums1[0]==nums2[i]?1:0;maxCount=Math.max(dp[0][i],maxCount);}for(int i=0;i<m;++i){dp[i][0]=nums1[i]==nums2[0]?1:0;maxCount=Math.max(dp[i][0],maxCount);}for(int i=1;i<m;++i){for(int j=1;j<n;++j){if(nums2[j]==nums1[i]){dp[i][j]=dp[i-1][j-1]+1;maxCount=Math.max(dp[i][j],maxCount);}}}return maxCount;}
}

1143. 最长公共子序列

dp[i][j]的定义跟上面不一样，这里子序列是不连续的，如果定义还要求是以元素结尾的子序列长度的话，i元素=j元素，dp[i][j]不一定是在dp[i-1][j-1]的基础上+1，就会很麻烦。

所以设置为：text1[0,i-1]和text2[0,j-1]范围内，最长公共子序列的长度.

最后返回的就是dp[m][n]

递推公式：如果相等的话，是在dp[i-1][j-1]的基础上+1。

如果不相等，不能直接跳过，比如abcde，ace，到了abc、ace的时候c!=e，那么dp[3][3]按照定义应该是2，等于dp[3][2]。把abc、ace倒过来，dp[3][3]又=dp[2][3]。A[i-1]和B[j-1]不相等，但是A[i-1]可能和B[j-1]之前的相等，B[j-1]可能和A[i-1]之前的相等，所以要取这两种情况的最大值。

采用跟上提一样的偏移写法：

class Solution {public int longestCommonSubsequence(String text1, String text2) {int m=text1.length(),n=text2.length();int[][] dp=new int[m+1][n+1];//text1[0,i-1]和text2[0,j-1]范围内，最长公共子序列的长度for(int i=1;i<=m;++i){for(int j=1;j<=n;++j){if(text1.charAt(i-1)==text2.charAt(j-1)){dp[i][j]=dp[i-1][j-1]+1;}else dp[i][j]=Math.max(dp[i-1][j],dp[i][j-1]);}}return dp[m][n];}
}

同样可以用滚动数组吗？

不行，

dp[i][j]取决于这三个元素，如果用滚动数组，无论行优先，还是列优先遍历，dp[i][j-1]/dp[i-1][j]都会把dp[i][j]覆盖。

1035. 不相交的线

跟上题一样。

392. 判断子序列

编辑距离问题的入门题目。用上面的方法然后判断dp[m][n]是否=s.length()的话，效率低。

所以也可以用双指针做一下：

class Solution {public boolean isSubsequence(String s, String t) {int m=s.length(),n=t.length();int sp=0,tp=0;while(sp<m && tp<n)//sp:s已经匹配了的右边界{if(s.charAt(sp)==t.charAt(tp)){sp++;}tp++;}if(sp==m)return true;return false;}
}

时间O(n)。

有一个进阶问题；

力扣题解给出一个跟S 无关的预处理DP数组的做法：dp[i][j] 表示字符串 t 中从位置 i 开始往后字符 j 第一次出现的位置。

递推公式：

初始化：有效的下标 i 就是0到n-1，所以多设置一个n ，让dp[n][j]都=n，代表位置不存在。这是判断false的条件。

遍历顺序：得到下标 i到n-1 的第一次位置，所以i 需要从大到小。

class Solution {public boolean isSubsequence(String s, String t) {int m=s.length(),n=t.length();int[][] dp=new int[n+1][26];//字符串 t 中从位置 i 开始往后字符 j 第一次出现的位置//初始化for(int i=0;i<26;++i){dp[n][i]=n;//代表不存在}for(int i=n-1;i>=0;--i)//和s无关，得到dp数组{for(int j=0;j<26;++j){if(t.charAt(i)==j+'a'){dp[i][j]=i;//更新位置}else dp[i][j]=dp[i+1][j];}}//检查S1、S2……int add=-1;for(int i=0;i<m;++i){add=dp[add+1][s.charAt(i)-'a'];//以上一次找到的位置的下一个为起点System.out.println(add);if(add==n)return false;}return true;}
}

过程大概就是：

s = "abc", t = "ahbgdc"

s[0]=a在t[0,n-1]的第一个位置，是0；

s[1]=b在t[1,n-1]的第一个位置，是2；

s[2]=c在t[3,n-1]的第一个位置，是5；

保证了s各字母在t中找到的位置是递增的，而且这个位置不等于代表不存在的n，就返回true。

115. 不同的子序列

仔细看题目，在s 的 子序列 中 t 出现的个数。s的子序列是不连续的，t是整个连续的。

定义dp的时候，dp[i][j]表示在s[0-i]（不一定以i结尾）中t[0,j]（连续，一定以j结尾）出现的个数。

所以这里dp[i][j]有两种可能：以s[i]结尾和不以s[i]结尾，这是分情况讨论的来源。

1、当s[i-1]==t[j-1]，以s[i-1]结尾的话，t[j-1]也定了，所以只能等于不包含这两个相同元素的个数，也就是dp[i-1][j-1]；

不以s[i-1]结尾的话，那就是不包含这个元素，所以要找这个元素之前子序列出现个数，即dp[i-1][j]。

递推公式题解中的解释，力扣给的逆序的DP：

2、当s[i-1]!=t[j-1]，肯定只会是不以s[i-1]结尾了，所以让s[0,i-2]和t[0,j-1]匹配，即dp[i-1][j]。

初始化：如果像上面的那样，初始化为0，结果只会是0。先看dp[i][0]，s[0-i-1]包含空串的数量，应该为1；而且空串也是空串的子串，所以dp[0][0]=1。dp[0][j]，空串包含t[0,j-1]的数量，应该是0。

class Solution {public int numDistinct(String s, String t) {int m=s.length(),n=t.length();int[][] dp=new int[m+1][n+1];//在s[0-i-1]（不要求以i结尾）的子序列中t[0,j-1]（要以j结尾）出现的个数for(int i=0;i<=m;++i)dp[i][0]=1;for(int i=1;i<=m;++i){for(int j=1;j<=n;++j){if(s.charAt(i-1)==t.charAt(j-1))dp[i][j]=dp[i-1][j ]+dp[i-1][j-1];else dp[i][j]=dp[i-1][j];}}return dp[m][n];}
}

用Java不用取余也能过。

也可以用滚动数组。注意内循环也得从大到小：

class Solution {public int numDistinct(String s, String t) {int m=s.length(),n=t.length();int[] dp=new int[n+1];//在s[0-i-1]（不要求以i结尾）的子序列中t[0,j-1]（要以j结尾）出现的个数dp[0]=1;for(int i=1;i<=m;++i){for(int j=n;j>=1;--j)//避免覆盖上一轮的{if(s.charAt(i-1)==t.charAt(j-1))dp[j]+=dp[j-1];// else dp[j]=dp[j];}}return dp[n];}
}

583. 两个字符串的删除操作

dp[i][j]定义：1[0—i]、2[0—j ]相等的最小步数。

初始化：根据定义，dp[0][i]应该=i；同理dp[0][j]=j。

2元素相等，那肯定这一步不用删除元素，直接等于之前的dp[i-1][j-1]

2个元素不相等的时候，需要删除，那就有三种情况。删一个有两种，或者两个都删。既然是最小步数，所以取最小值。

class Solution {public int minDistance(String word1, String word2) {int m=word1.length(),n=word2.length();int[][] dp=new int[m+1][n+1];//1[0,i-1]、2[0,j-1]相等的最小步数for (int i = 1; i <= m; i++)dp[i][0] = i;for (int j = 1; j <= n; j++)dp[0][j] = j;for(int i=1;i<=m;++i){for(int j=1;j<=n;++j){if(word1.charAt(i-1)==word2.charAt(j-1)){dp[i][j]=dp[i-1][j-1];}else dp[i][j]=Math.min(Math.min(dp[i-1][j],dp[i][j-1])+1,dp[i-1][j-1]+2);}}return dp[m][n];}
}

也不能滚动数组。

最后，综合题：

72. 编辑距离

相等和上面是一样的。

不相等:（注意只能操作word1）

增：dp[i][j-1]+1。增了之后新增的和2[j-1]相等。

删：dp[i-1][j]+1

换：dp[i-1][j-1]+1

关于增删情况的解释：

所以取这三个的最小值。

class Solution {public int minDistance(String word1, String word2) {int m=word1.length(),n=word2.length();int[][] dp=new int[m+1][n+1];//1[0,i-1]转化成2[0,j-1]for(int i=1;i<=m;++i)dp[i][0]=i;for(int j=1;j<=n;++j)dp[0][j]=j;for(int i=1;i<=m;++i){for(int j=1;j<=n;++j){if(word1.charAt(i-1)==word2.charAt(j-1)){dp[i][j]=dp[i-1][j-1];}else {dp[i][j]=1+Math.min(dp[i-1][j-1],Math.min(dp[i][j-1],dp[i-1][j]));}}}return dp[m][n];}
}