102 交叉字符串（Interleaving String）

1 题目

题目：交叉字符串（Interleaving String）
描述：给出三个字符串s1、s2、s3，判断s3是否由s1和s2交叉构成。

lintcode题号——29，难度——hard

样例1：

输入：
s1 = "aabcc"
s2 = "dbbca"
s3 = "aadbbcbcac"
输出：true
解释：s3 是由 s1 与 s2 交叉构成。

样例2：

输入：
s1 = ""
s2 = ""
s3 = "1"
输出：false
解释：s3 不是由 s1 与 s2 交叉构成。

样例3：

输入：
s1 = "aabcc"
s2 = "dbbca"
s3 = "aadbbbaccc"
输出：false
解释：s3 不是由 s1 与 s2 交叉构成。

2 解决方案

2.1 思路

  使用动态规划的方式解，将状态dp[i][j]定义为表示s1的前i个和s2的前j个能不能构成s3的前i+j个，则如果s1的第i字符与s2第j字符与s3的第i+j字符都相等，则只要dp[i - 1][j]、dp[i][j - 1]中一个为真，dp[i][j]即可为真；如果只有s1的第i字符与s3的第i+j字符相等，则dp[i - 1][j]为真，dp[i][j]即为真；如果只有s2的第j字符与s3的第i+j字符相等，则dp[i][j - 1]为真，dp[i][j]即为真，理清动态规划的四要素即可解出。

双序列型动态规划：由于将状态定义成前i个字符的状态，所以前0个对象的状态~前i个对象的状态，一共有i+1个状态，所以容器的长度需要增加一位，注意与坐标型动态规划区分。

2.3 时间复杂度

  算法会遍历二维数组，假设s1字符串和s2字符串的长度分别为m、n，则算法的时间复杂度为O(m*n)。

2.4 空间复杂度

  使用了二维数组数据结构，容量为m*n，空间复杂度为O(m*n)。

3 源码

细节：

1. 动态规划的四要素：状态、方程、初始化、答案。（四要素在之前的题目数字三角形¹中有详细介绍）
2. 状态：用dp[i][j]表示s1的前i个和s2的前j个能不能构成s3的前i+j个。
3. 方程：分三种情况，如果s1的第i字符与s2第j字符与s3的第i+j字符都相等，则只要dp[i - 1][j]、dp[i][j - 1]中一个为真，dp[i][j]即可为真；如果只有s1的第i字符与s3的第i+j字符相等，则dp[i - 1][j]为真，dp[i][j]即为真；如果只有s2的第j字符与s3的第i+j字符相等，则dp[i][j - 1]为真，dp[i][j]即为真。
4. 初始化：s1前i个字符能不能独立构成s3的前i个字符，对应dp[i][0]；s2的前j个字符能不能独立构成s3的前j个字符，对应dp[0][j]。
5. 答案：s1的所以字符和s2的所有字符能不能构成s3的所有字符，即dp[maxI]dp[maxJ]。

C++版本：

/**
* @param s1: A string
* @param s2: A string
* @param s3: A string
* @return: Determine whether s3 is formed by interleaving of s1 and s2
*/
bool isInterleave(string &s1, string &s2, string &s3) {
    // write your code here
    if (s1.empty())
    {
        return s2 == s3;
    }
    if (s2.empty())
    {
        return s1 == s3;
    }

    // 状态：dp[i][j]表示s1的前i个和s2的前j个能不能构成s3的前i+j个
    vector<vector<int>> dp(s1.size() + 1, vector<int>(s2.size() + 1));

    // 初始化：s1前i个字符能不能独立构成s3的前i个字符；s2的前j个字符能不能独立构成s3的前j个字符
    for (int i = 0; i < dp.size(); i++)
    {
        if (s1.substr(0, i) == s3.substr(0, i))
        {
            dp[i][0] = 1;
        }
    }
    for (int j = 0; j < dp.front().size(); j++)
    {
        if (s2.substr(0, j) == s3.substr(0, j))
        {
            dp[0][j] = 1;
        }
    }

    for (int i = 1; i < dp.size(); i++)
    {
        for (int j = 1; j < dp.front().size(); j++)
        {
            // 方程：如果s1的第i字符与s2第j字符与s3的第i+j字符都相等，则只要dp[i - 1][j]、dp[i][j - 1]中一个为真，dp[i][j]即可为真
            if (s1[i - 1] == s3[i + j - 1] && s2[j - 1] == s3[i + j - 1])
            {
                dp[i][j] = dp[i - 1][j] || dp[i][j - 1];
            }
            // 方程：如果只有s1的第i字符与s3的第i+j字符相等，则dp[i - 1][j]为真，dp[i][j]即为真
            else if (s1[i - 1] == s3[i + j - 1])
            {
                dp[i][j] = dp[i - 1][j];
            }
            // 方程：如果只有s2的第j字符与s3的第i+j字符相等，则dp[i][j - 1]为真，dp[i][j]即为真
            else if (s2[j - 1] == s3[i + j - 1])
            {
                dp[i][j] = dp[i][j - 1];
            }
        }
    }

    return dp[dp.size() - 1][dp.front().size() - 1]; // 答案：s1的所以字符和s2的所有字符能不能构成s3的所有字符
}

---

1. 数字三角形：https://blog.csdn.net/SeeDoubleU/article/details/124678103 ↩︎