初识动态规划（二维）

• 动态规划的核心设计思想是数学归纳法。
• 动态规划要明确状态与选择。
• 动态规划从暴力解法入手，借助dp数组，完成算法优化。

下面从最长递增子序列（LCS）进入二维动态规划的学习。

最长公共子序列

题目链接（LCR 095. 最长公共子序列 - 力扣（LeetCode））

题目描述：给定两个字符串 text1 和 text2，返回这两个字符串的最长 公共子序列 的长度。如果不存在 公共子序列 ，返回 0 。

字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。

dp[i][j] = dp[i-1][j-1]+1;
dp[i][j] = Math.max(dp[i-1][j], dp[i][j-1]);

s1：babcde，s2：ab

	..	b	a	b	c	d	e
..	0	0	0	0	0	0	0
a	0	0	1	1	1	1	1
b	0	1	1	2	2	2	2

• 字符串为空时，公共子序列长度为0，故dp数组第一行和第一列初始化为0；
• 当s1[i] == s2[j]，考虑s1[0：i-1] 和s2[0：j-1]的最长公共子序列，再增加一个字符（即公共字符）即可得到 s1​[0:i] 和 s2​[0:j] 的最长公共子序列，因此dp[i][j] = dp[i-1][j-1]+1；
• 当s1[i] != s2[j]，考虑s1[0：i-1] 和s2[0：j]的最长公共子序列 与 考虑s1[0：i] 和s2[0：j-1]的最长公共子序列 ，再增加一个字符（即公共字符）即可得到 s1​[0:i] 和 s2​[0:j] 的最长公共子序列，因此dp[i][j] = Math.max(dp[i-1][j], dp[i][j-1])；

class Solution {
    public int longestCommonSubsequence(String text1, String text2) {
        char[] t1 = text1.toCharArray();
        char[] t2 = text2.toCharArray();
        int len1 = t1.length;
        int len2 = t2.length;
        int[][] dp = new int[len1+1][len2+1];
        for(int i = 1; i <= len1; i++) {
            for(int j = 1; j <= len2; j++) {
                if(t1[i-1] == t2[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[len1][len2];
    }
}

编辑距离

题目链接（72. 编辑距离 - 力扣（LeetCode））

题目描述：

给你两个单词 word1 和 word2， 请返回将 word1 转换成 word2 所使用的最少操作数  。

你可以对一个单词进行如下三种操作：

• 插入一个字符
• 删除一个字符
• 替换一个字符

相对于求解最长公共子序列，编辑距离则是将这个过程逆转过来。

增：dp[i][j] = dp[i][j - 1] + 1
删：dp[i][j] = dp[i - 1][j] + 1
改：dp[i][j] = dp[i - 1][j - 1] + 1

dp[i][j] = dp[i-1][j-1];
dp[i][j] = Math.min(dp[i-1][j]+1, dp[i][j-1]+1,dp[i-1][j-1]+1);

s1：babcde，s2：ab

• 字符串为空时，需要不断插入字符，故第一行和第一列的数字依次递增；
• 按顺序计算，当计算 dp[i][j] 时，dp[i - 1][j] ， dp[i][j - 1] ， dp[i - 1][j - 1] 均已经确定了
• 配合增删改这三种操作，需要对应的 dp 把操作次数加一，取三种的最小
• 如果刚好这两个字母相同 word1[i - 1] = word2[j - 1] ，那么可以直接参考 dp[i - 1][j - 1] ，操作不用加一

class Solution {
    public int minDistance(String word1, String word2) {
        char[] w1 = word1.toCharArray();
        char[] w2 = word2.toCharArray();
        int[][] dp = new int[w1.length+1][w2.length+1];
        for(int i = 1; i <= w1.length; i++) {
            dp[i][0] = i;
        }
        for(int i = 1; i <= w2.length; i++) {
            dp[0][i] = i;
        }
        for(int i = 1; i <= w1.length; i++) {
            for(int j = 1; j <= w2.length; j++) {
                if(w1[i-1] == w2[j-1]) {
                    dp[i][j] = dp[i-1][j-1];
                }else {
                    dp[i][j] = Math.min(dp[i-1][j-1]+1, 
                            Math.min(dp[i-1][j]+1, dp[i][j-1]+1));
                }
            }
        }
        return dp[w1.length][w2.length];
    }
}

总结

• 最长公共子序列是一种比较常用的模板，很多问题是这个问题的改版。