动态规划: 字符串系列(上)

动态规划: 字符串系列(上)

序言:
本文记录用动态规划解决的常见字符串问题。

0. 概述
动态规划(Dynamic Programming, DP)是典型地以空间换时间的算法，当暴力法(Brute Force, BF)无法在规定时间内解决问题时，动态规划便能体现出其强大的作用。其主要思路是，当原问题可以被分解成多个子问题，且子问题与原问题拥有重叠的结构，我们可以用多个子问题的解递推出原问题的解(非官话，只为理解)。

1. 最长公共子串(LintCode 79)
问题描述：给出两个字符串，找到最长公共子串，并返回其长度。

输入: s = “ABCD”, t = “EABDF”
输出: 2
解释: s 和 t 的最长公共子串为 “AB”

假定 $s$ 的长度为 $n$，$t$ 的长度为 $m$。
首先考虑暴力破解, $s$ 有 $n^2$ (实际是$n(n+1)/2+1$，此处近似) 个子串，$t$ 有 $m^2$ 个子串，复杂度为 $O(n^2{m}^2)$
但是暴力破解完全割裂了各个子问题的相互联系性。
倘若记 $s$ 中以下标 $i-1$ 结尾的子串，与 $t$ 中以下标 $j-1$ 结尾的子串最长公共子串的长度为$dp[i][j]$，则状态转移方程为

$$dp[i][j]=\{\begin{array}{rlr}& dp[i-1][j-1]+1,& s[i-1]=t[j-1]\\ & 0,& \mathrm{o}\mathrm{t}\mathrm{h}\mathrm{e}\mathrm{r}\mathrm{w}\mathrm{i}\mathrm{s}\mathrm{e}\end{array}$$
我们定义的$dp[i][j]$很关键，其“定死”了 $s$ 必须取到$s[i-1]$字符以及 $t$ 必须取到 $t[j-1]$ 字符，倘若两者不等，则绝无法匹配；倘若两者相等，则可以向上个状态 $dp[i-1][j-1]$ 转移而来。

• C++ 实现，时间复杂度$O(nm)$

class Solution {
public:
    /**
     * @param A: A string
     * @param B: A string
     * @return: the length of the longest common substring.
     */
    int longestCommonSubstring(string &A, string &B) {
        int len1 = A.size(), len2 = B.size();
        int ans = 0;
        vector<vector<int> > dp(len1 + 1, vector<int>(len2 + 1, 0));
        for (int i = 1; i <= len1; ++i) {
            for (int j = 1; j <= len2; ++j) {
                if (A[i - 1] == B[j - 1]) {
                    dp[i][j] = 1 + dp[i - 1][j - 1];
                    ans = max(ans, dp[i][j]);
                }
            }
        }
        return ans;
    }
};

2. 最长公共子序列(LintCode 77)
问题描述：给出两个字符串，找到最长公共子序列(LCS)，返回LCS的长度。

输入: s = “ABCD”, t = “EABDF”
输出: 3
解释: s 和 t 的最长公共子序列为 “ABD”

不同于子串，子序列的定义更加宽松。对于字符串 $s$, 子串要求从 $s$ 中顺序取出，并且严格相邻；而子序列则只要求顺序取出，而不一定相邻(可以不连续)

子序列的定义等于直接宣告暴力破解的失败，但是对于动态规划而言，却无足轻重。可以依旧挪用上题的 $dp$ 定义，记 $s$ 中以下标 $i-1$ 结尾的子序列，与 $t$ 中以下标 $j-1$ 结尾的子序列的最长公共子序列的长度为$dp[i][j]$。因为，子串也是子序列，因此，只要拓展状态转移方程即可。
$$dp[i][j]=\{\begin{array}{rlr}& dp[i-1][j-1]+1,& s[i-1]=t[j-1]\\ & \mathrm{m}\mathrm{a}\mathrm{x}(dp[i-1][j],dp[i][j-1]),& \mathrm{o}\mathrm{t}\mathrm{h}\mathrm{e}\mathrm{r}\mathrm{w}\mathrm{i}\mathrm{s}\mathrm{e}\end{array}$$
子序列相较于子串的特殊在于，$s$ 中以下标 $i-1$ 结尾的子序列其本身不一定必须取到$s[i-1]$， 因此转移方程也变得更加宽松。

• C++ 实现，时间复杂度$O(nm)$

class Solution {
public:
    /**
     * @param A: A string
     * @param B: A string
     * @return: The length of longest common subsequence of A and B
     */
    int longestCommonSubsequence(string &A, string &B) {
        int len1 = A.size(), len2 = B.size();
        vector<vector<int> > dp(len1 + 1, vector<int>(len2 + 1, 0));
        int ans = 0;
        for (int i = 1; i <= len1; ++i) {
            for (int j = 1; j <= len2; ++j) {
                if (A[i - 1] == B[j - 1]) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                } else {
                    dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
                }
                ans = max(ans, dp[i][j]);
            }
        }
        return ans;
    }
};

3.字符串相似度/编辑距离(LeetCode 72)
给定两个单词 word1 和 word2，计算出将 word1 转换成 word2 所使用的最少操作数 。

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

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

输入: word1 = “horse”, word2 = “ros”
输出: 3
解释:
horse -> rorse (将’h’ 替换为 ‘r’)
rorse -> rose (删除 ‘r’) rose -> ros (删除 ‘e’)

仍旧沿用“结尾”法定义 $dp$， 记 $s$ 中以下标 $i-1$ 结尾的子串，与 $t$ 中以下标 $j-1$ 结尾的子串的最小距离为 $dp[i][j]$，则
$$\begin{array}{rl}& t_1=1+\mathrm{m}\mathrm{i}\mathrm{n}(dp[i][j-1],dp[i-1][j])\\ & t_2=\{\begin{array}{rlr}& dp[i-1][j-1],& s[i-1]=t[j-1]\\ & dp[i-1][j-1]+1,& \mathrm{o}\mathrm{t}\mathrm{h}\mathrm{e}\mathrm{r}\mathrm{w}\mathrm{i}\mathrm{s}\mathrm{e}\end{array}\\ & dp=\mathrm{m}\mathrm{i}\mathrm{n}(t_1,t_2)\end{array}$$
具体而言，$dp[i][j]$ 有三种转移方式

1. $dp[i-1][j]$ 转移到 $dp[i][j]$，即从 $s$ 中多取向后一个字符，此时对 $s$ 动用“删除”操作，或者说对 $t$ 动用“插入”操作
2. $dp[i][j-1]$ 转移到 $dp[i][j]$，即从 $t$ 中多取向后一个字符，此时对 $t$ 动用“删除”操作，或者说对 $s$ 动用“插入”操作
3. $dp[i-1][j-1]$ 转移到 $dp[i][j]$, 即分别从 即从 $s$, $t$ 中多向后取一个字符。若取出的两个字符相等, 无需操作；反之，动用“替换”操作。

• C++ 实现, 时间复杂度$O(nm)$

class Solution {
public:
    int minDistance(string word1, string word2) {
        int len1 = word1.size(), len2 = word2.size();
        if (len1 == 0 || len2 == 0) return len1 + len2;
        
        vector<vector<int>> dp(len1 + 1, vector<int>(len2 + 1, 0));
        for (int i = 1; i <= len1; ++i) dp[i][0] = i;
        for (int j = 1; j <= len2; ++j) dp[0][j] = j;
        
        for (int i = 1; i <= len1; ++i) {
            for (int j = 1; j <= len2; ++j) {
                int tar1 = 1 + min(dp[i][j - 1], dp[i - 1][j]);
                int tar2 = word1[i - 1] == word2[j - 1] ? dp[i - 1][j - 1] : dp[i - 1][j - 1] + 1;
                dp[i][j] = min(tar1, tar2);
            }
        }
        return dp[len1][len2];
    }
};

ajaxlt的GitHub入口: https://github.com/ajaxlt/BasicAlgorithoms/tree/master/动态规划/字符串类型