动态规划之子序列问题

子序列问题是常见的算法问题，子序列问题本身就相对子串、子数组更困难一些，因为前者是不连续的序列，而后两者是连续的，就算穷举都不容易，更别说求解相关的算法问题了。
子序列问题很可能涉及到两个字符串，比如让你求两个字符串的最长公共子序列，如果没有一定的处理经验，真的不容易想出来。
其实就有两种模板，相关问题只要往这两种思路上想，十拿九稳。

一般来说，这类问题都是让你求一个最长子序列，因为最短子序列就是一个字符嘛，没啥可问的。一旦涉及到子序列和最值，那几乎可以肯定，考察的是动态规划技巧，时间复杂度一般都是 O(n^2)。原因很简单，你想想一个字符串，它的子序列有多少种可能？起码是指数级的吧，这种情况下，不用动态规划技巧，还想怎么着呢？

既然要用动态规划，那就要定义 dp 数组，找状态转移关系。我们说的两种思路模板，就是 dp 数组的定义思路。不同的问题可能需要不同的 dp 数组定义来解决。

1.两种思路：
第一种思路模板是一个一维的 dp 数组：

int n = array.length;
int[] dp = new int[n];

for (int i = 1; i < n; i++) {
    for (int j = 0; j < i; j++) {
        dp[i] = 最值(dp[i], dp[j] + ...)
    }
}

举个例子:最长递增子序列，在这个思路中 dp 数组的定义是：

在子数组array[0..i]中，以*array[i]*结尾的目标子序列（最长递增子序列）的长度是dp[i]。
为啥最长递增子序列需要这种思路呢？前文说得很清楚了，因为这样符合归纳法，可以找到状态转移的关系

第二种思路模板是一个二维的 dp 数组：

int n = arr.length;
int[][] dp = new dp[n][n];

for (int i = 0; i < n; i++) {
    for (int j = 1; j < n; j++) {
        if (arr[i] == arr[j]) 
            dp[i][j] = dp[i][j] + ...
        else
            dp[i][j] = 最值(...)
    }
}

这种思路运用相对更多一些，尤其是涉及两个字符串/数组的子序列。本思路中 dp 数组含义又分为「只涉及一个字符串」和「涉及两个字符串」两种情况。
涉及两个字符串/数组时（比如最长公共子序列），dp 数组的含义如下：在子数组arr1[0..i]和子数组arr2[0..j]中，我们要求的子序列（最长公共子序列）长度为dp[i][j]。
只涉及一个字符串/数组时（比如最长回文子序列），dp 数组的含义如下：在子数组array[i..j]中，我们要求的子序列（最长回文子序列）的长度为dp[i][j]。

实例1：最长回文子序列leet516
给定一个字符串 s ，找到其中最长的回文子序列，并返回该序列的长度。可以假设 s 的最大长度为 1000 。

这个问题对 dp 数组的定义是：在子串s[i..j]中，最长回文子序列的长度为dp[i][j]。一定要记住这个定义才能理解算法。
为啥这个问题要这样定义二维的 dp 数组呢？我们前文多次提到，找状态转移需要归纳思维，说白了就是如何从已知的结果推出未知的部分，这样定义容易归纳，容易发现状态转移关系。

具体来说，如果我们想求dp[i][j]，假设你知道了子问题dp[i+1][j-1]的结果（s[i+1..j-1]中最长回文子序列的长度），你是否能想办法算出dp[i][j]的值（s[i..j]中，最长回文子序列的长度）呢？

可以！这取决于s[i]和s[j]的字符：如果它俩相等，那么它俩加上s[i+1..j-1]中的最长回文子序列就是s[i..j]的最长回文子序列：如果它俩不相等，说明它俩不可能同时出现在s[i..j]的最长回文子序列中，那么把它俩分别加入s[i+1..j-1]中，看看哪个子串产生的回文子序列更长即可：

if (s[i] == s[j])
    // 它俩一定在最长回文子序列中
    dp[i][j] = dp[i + 1][j - 1] + 2;
else
    // s[i+1..j] 和 s[i..j-1] 谁的回文子序列更长？
    dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]);

至此，状态转移方程就写出来了，根据 dp 数组的定义，我们要求的就是dp[0][n - 1]，也就是整个s的最长回文子序列的长度。

首先明确一下 base case，如果只有一个字符，显然最长回文子序列长度是 1，也就是dp[i][j] = 1,(i == j)。

因为i肯定小于等于j，所以对于那些i > j的位置，根本不存在什么子序列，应该初始化为 0。

另外，看看刚才写的状态转移方程，想求dp[i][j]需要知道dp[i+1][j-1]，dp[i+1][j]，dp[i][j-1]这三个位置；再看看我们确定的 base case，填入 dp 数组之后是这样：

class Solution {
    public int longestPalindromeSubseq(String s) {
        int n=s.length();
        int[][] dp=new int[n][n];

        for(int i=0;i<n;i++){
            dp[i][i]=1;
        }

        for(int i=n-1;i>=0;i--){
            for(int j=i+1;j<n;j++){
                if(s.charAt(i)==s.charAt(j)){
                    dp[i][j]=2+dp[i+1][j-1];
                }else{
                    dp[i][j]=Math.max(dp[i+1][j],dp[i][j-1]);
                }
            }
        }

        return dp[0][n-1];

    }
}

目前的总结：
步骤一：确定dp数组（无论是一维还是二维）的定义和状态转移关系（这两个是一体的，可以通过经验来确定，关键的一点在于
能通过已知的推出未知的，即找到明确的dp[i][j]与dp[i+1][j-1]，dp[i+1][j]，dp[i][j-1]的数学关系，也就是 状态转移方程。
步骤二：确定base case，这里关键在于列出全部base case
步骤三：根据base case，画出dp数组（无论是一维还是二维），根据状态转移方程和base case确定遍历的方向
步骤四：明确最后要输出的是dp数组中的哪一个。

实例2：最长公共子序列leet1143
给定两个字符串 text1 和 text2，返回这两个字符串的最长公共子序列的长度。

按照之前总结的步骤，第一步是思考dp数组的定义和状态转移关系，那么首先定义dp[i] [j]的意义是text1中的[0,........i] 与 text2 中的[0...........j] 所形成的最长公共子序列。那么能通过已知的推出未知的吗，这里与上面一题基本一致，dp[i] [j] 相对于 dp[i-1] [j-1] 来说就是新增了两个字母，当这两个字母相等的时候，就是会公共子序列会增加1位，那就是dp[i-1] [j-1] + 1，当不相等时，那么可能其中一个可以使得公共子序列+1位，也可能都不加，即max（ dp[i] [j-1] 和 dp[i-1] [j] 和 dp[i-1] [j-1]）但发现 dp[i-1] [j-1] 一定比前两个小或等于，因为求最大值，所以没必要列入。

第二步是思考base case，这里有一个麻烦，因为能确定的base case是两个或其中一个里面什么都没有，那么公共子序列长度一定为0，但现在的定义的开头是text.charAt(0) 就是第一个值，这不是base case，所以略微更改dp定义，dp[i] [j] 表示text1[0....i-1]
text2[0.........j-1]的最长公共子序列。 也相当于一个 索引偏移。

class Solution {
    public int longestCommonSubsequence(String text1, String text2) {
        int m=text1.length();
        int n=text2.length();

        int[][] dp=new int[m+1][n+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定义是[0.........i] ) 思路非常清晰但是需要索引偏移，还有另外的一种方法：自顶向下的带备忘录的动态规划。

思考的过程还是一样，定义dp[i] [j] 表示text1的[i.......] 和 text2的[j........] 部分的最长公共子序列，（即该点到末尾），状态转移方程与上一种一样，分为新加的两个一样与不一样开始讨论，这里呢，当不一样的时候，也是那三种情况比较选max，但因为第三种情况事实上被前两种包含了所以无需列出。当然这里的关系是i，j与 i+1，j+1；i，j+1；i+1,j 之间的关系。

当然，由于要添加一个备忘录以防止反复计算重复值，dp不能直接用数组形式，而是得用一个函数来进行。

class Solution {

    int[][] memo;
    public int longestCommonSubsequence(String text1, String text2) {
        int n=text1.length();
        int m=text2.length();
        memo=new int[n][m];
        for (int[] row : memo) 
        Arrays.fill(row, -1);
        return dp(text1,0,text2,0);
    }

    int dp(String text1,int i,String text2,int j){
        if(i==text1.length()||j==text2.length()){
            return 0;
        }

        if (memo[i][j] != -1) {
        return memo[i][j];
    }

        if(text1.charAt(i)==text2.charAt(j)){
            memo[i][j] = 1 + dp(text1, i + 1, text2, j + 1);
        }else {
        // s1[i] 和 s2[j] 至少有一个不在 lcs 中
        memo[i][j] = Math.max(
            dp(text1, i + 1, text2, j),
            dp(text1, i, text2, j + 1)
        );
        }

        return memo[i][j];
    }
}

这里有很多细节，比如memo的定义拆成两部分，以及Arrays.fill的用法。

两种方法都要掌握，但思考的时候可以只按照一种来，个人比较喜欢自底向上的动态规划

实例3：583.两个字符串的删除操作
看完题目就能想到与上面一题一样，只需改一下return的值就可以

class Solution {
    public int minDistance(String word1, String word2) {
        int n=word1.length();
        int m=word2.length();

        int[][] dp=new int[n+1][m+1];

        for(int i=1;i<n+1;i++){
            for(int j=1;j<m+1;j++){
                if(word1.charAt(i-1)==word2.charAt(j-1)){
                    dp[i][j]=dp[i-1][j-1]+1;
                }else{
                    dp[i][j]=Math.max(dp[i][j-1],dp[i-1][j]);
                }
            }
        }
        int longlength=dp[n][m];
        return (n+m-2*longlength);

    }
}

实例4：
再写一遍

实例5：编辑距离leet72
编辑距离问题就是给我们两个字符串s1和s2，只能用三种操作，让我们把s1变成s2，求最少的操作数。需要明确的是，不管是把s1变成s2还是反过来，结果都是一样的，所以后文就以s1变成s2举例。
解决两个字符串的动态规划问题，一般都是用两个指针i,j分别指向两个字符串的最后，然后一步步往前走，缩小问题的规模。

(一)、当word1[i]==word2[j]时,由于遍历到了i和j,说明word1的0~i-1和word2的0~j-1的匹配结果已经生成,
由于当前两个字符相同,因此无需做任何操作,dp[i][j]=dp[i-1][j-1]
(二)、当word1[i]!=word2[j]时,可以进行的操作有3个:
      ① 替换操作:可能word1的0~i-1位置与word2的0~j-1位置的字符都相同,
           只是当前位置的字符不匹配,进行替换操作后两者变得相同,
           所以此时dp[i][j]=dp[i-1][j-1]+1(这个加1代表执行替换操作)
      ②删除操作:若此时word1的0~i-1位置与word2的0~j位置已经匹配了,
         此时多出了word1的i位置字符,应把它删除掉,才能使此时word1的0~i(这个i是执行了删除操作后新的i)
         和word2的0~j位置匹配,因此此时dp[i][j]=dp[i-1][j]+1(这个加1代表执行删除操作)
      ③插入操作:若此时word1的0~i位置只是和word2的0~j-1位置匹配,
          此时只需要在原来的i位置后面插入一个和word2的j位置相同的字符使得
          此时的word1的0~i(这个i是执行了插入操作后新的i)和word2的0~j匹配得上,
          所以此时dp[i][j]=dp[i][j-1]+1(这个加1代表执行插入操作)
      ④由于题目所要求的是要最少的操作数:所以当word1[i] != word2[j] 时,
          需要在这三个操作中选取一个最小的值赋格当前的dp[i][j]
(三)总结:状态方程为:
if(word1[i] == word2[j]):
      dp[i][j] = dp[i-1][j-1]
else:
       min(dp[i-1][j-1],dp[i-1][j],dp[i][j-1])+1


代码中word1.charAt(i-1)==word2.charAt(j-1)的原因是:
     初始化DP Table时dp[i][0]和dp[0][j]已经填写完成,所以接下来填表需要从1开始,
     但是字符的比较需要从0开始,因此才这样子写

dp[i,j] 表示 word1[0...........i] 与 word2 [0.............j] 的最小操作数
另外，Math.min 只支持两个数比较。

在考虑完dp和状态转移方程之后，需要注意的就是base case。
当word1中 i为0时，那么word2 中有多少数，就要增添多少；反之word2 为0时，word1中有多少数就要删除多少。

class Solution {
    public int minDistance(String word1, String word2) {
        int n=word1.length();
        int m=word2.length();

        int[][] dp=new int[n+1][m+1];

        for(int i=1;i<n+1;i++){
            dp[i][0]=i;
        }
        for(int j=1;j<m+1;j++){
            dp[0][j]=j;
        }

        for(int i=1;i<n+1;i++){
            for(int j=1;j<m+1;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-1]+1,dp[i-1][j]+1),dp[i][j-1]+1);
                }
            }
        }
        return dp[n][m];

    }
}