二刷力扣——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];
    }
}

编辑距离总结篇

dp大小一般都设置[m+1][n-1]。dp[i][j]代表1[i-1]和2[j-1] 的关系。是有意义的，比如1、2是字符串的话，dp[0]就涉及到空串。

1、判断子序列：可以DP，可以双指针。

2、不同的子序列：比较难，要把握题目意思，两种情况都要考虑（有/无 s子序列结尾元素）。有的情况是dp几，无的情况是dp几。

有的话是dp[i-1][j-1]。因为i-1和j-1能对上，所以这两个固定了，就不考虑了，只看前面的个数。

无的话是dp[i-1][j]，只能确定不考虑i-1，考虑i-2及之前的；j-1不知道和谁对上，所以j-1仍然要考虑，即为dp[i-1][j]

这里的思想和编辑距离是差不多的。

3、两个字符串删除操作

不相等的时候，有三种情况，算好做一点。

4、编辑距离

有了前面的铺垫好做一些了。

要想清楚的仍是删/增/改分别对应dp几：

子数组，子序列问题，dp的定义要思考，要不要以当前元素结尾?结尾的话好递推吗？…

647. 回文子串

这里dp定义是：[i,j]范围内是回文子串，为true。

如果定义是数量的话，dp[i][j]只知道i、j 包含内的子串数目，不能像两端更大范围的序列传达自己是不是回文子串，递推公式也不方便弄，所以定义dp[i][j]就为bool型。

回文子串涉及到两端，如果i 和 j 相同，同时里面的子串[i+1,j-1]是回文的（DP数组记录），就能确定这是回文子串，count++。

特殊的，i+1>j-1，那么①里面的子串就没有,【i,j】就两个字母，当然也是回文子串。②i==j，单个字母也是回文子串：

class Solution {
    public int countSubstrings(String s) {
        int n=s.length();
        boolean[][] dp=new boolean[n][n];//[i,j]是不是回文子串
        int count=0;//统计
        for(int i=n-1;i>=0;--i)
        {
            for(int j=i;j<n;++j)
            {
                if(s.charAt(i)==s.charAt(j)){
                    if(j<=i+1||dp[i+1][j-1]==true)
                    {
                        dp[i][j]=true;
                        count++;
                        System.out.println(i+"  "+j);
                    }
                }
            }
        }
        return count;
    }
}

注意要先得到dp[i+1][j-1]，所以i从后往前。

时间、空间O(n2)；稍微有点慢。

2、力扣题解的中心扩展法：

每个回文，回文中心有偶数个和奇数个两种情况。也就是最中间是两个，还是一个。

所以遍历所有的回文中心(i,j)，指针扩展（l,r），然后统计：

class Solution {
    public int countSubstrings(String s) {
        int n=s.length();
        int count=0;
        for(int i=0;i<n;++i)
        {
            for(int j=0;j<2;++j)
            {
                //确定回文中心左右起点
                int l=i;
                int r=i+j;
                while(l>=0 && r<n && s.charAt(l--)==s.charAt(r++))
                {
                    count++;
                }
            }
        }
        return count;
    }
}

空间O(1)

516. 最长回文子序列

这里是回文子序列，不连续的

dp可以用长度表示了，

class Solution {
    public int longestPalindromeSubseq(String s) {
        int n=s.length();
        int maxLength=1;
        int[][] dp=new int[n][n];//[i,j]回文子序列的长度
        for(int i=n-1;i>=0;--i)
        {
            dp[i][i]=1;//必须
            for(int j=i+1;j<n;++j)
            {
                if(s.charAt(i)==s.charAt(j))
                {
                    dp[i][j]=dp[i+1][j-1]+2;
                }
                else
                {
                    dp[i][j]=Math.max(dp[i+1][j],dp[i][j-1]);
                }
                maxLength=Math.max(dp[i][j],maxLength);
            }
        }
        return maxLength;
    }
}

递推公式和上面的思想一致，注意的是2个特殊情况（i+1>=j-1，i到j只有一个或者2个元素）：

①i==j：需要写出来dp[i][j]=1。

②i+1<=j：+1==j的时候dp[i][j]=2。不用分开写出，因为dp[i+1][j-1]是左下角的元素，左下角都为0而且不会更新，所以<=的时候都可以用dp[i][j]=dp[i+1][j-1]+2；得到。

不相等的时候，最长回文子序列要么不包含s[i]，要么不包含s[j]，所以有两种情况：不考虑s[i]或不考虑s[j]。取两个的最大值即可：dp[i][j]=max(dp[i][j-1],dp[i+1][j]);

也不能滚动数组优化，