面试经典150题 | LeetCode-97.交错字符串

问题描述

给定三个字符串 s1、s2、s3，请你帮忙验证 s3 是否是由 s1 和 s2 交错 组成的。

两个字符串 s 和 t 交错 的定义与过程如下，其中每个字符串都会被分割成若干 非空 子字符串：

• s = s1 + s2 + ... + sn
• t = t1 + t2 + ... + tm
• |n - m| <= 1
• 交错 是 s1 + t1 + s2 + t2 + s3 + t3 + ... 或者 t1 + s1 + t2 + s2 + t3 + s3 + ...

注意：a + b 意味着字符串 a 和 b 连接。

问题分析

记字符串s1的长度为n1，字符串s2的长度为n2，字符串s3的长度为m

字符串s3的最后一个元素s3[m-1]可以由s1[n1-1]或s2[n2-2]组成。

• 若s3[m-1] == s1[n1-1]，则问题可以转化为判断s3[0...m-2]能否由s1[0...n1-2]和s2交错组成。
• 若s3[m-1] == s2[n2-1]，则问题可以转化为判断s3[0...m-2]能否由s1和s2[0...n2-2]交错组成。

算法描述

状态表示：dp[i][j]表示s3[0...i+j]能否由s1[0...i]和s2[0...j]交错组成。

状态计算：

• 若s3[i+j] == s1[i]：dp[i][j] = dp[i][j] || dp[i-1][j]
• 若s3[i+j] == s2[j]：dp[i][j] = dp[i][j] || dp[i][j-1]

状态压缩

这里我们可以观察到，状态dp[i][j]的第i行只和第i-1行相关，因此，我们就可以将空间维度缩减成一维。

压缩后的状态转移方程如下：

• 若s3[i+j] == s1[i]：dp[j] = dp[j]
• 若s3[i+j] == s2[j]：dp[j] = dp[j] || dp[j-1]

复杂度分析

时间复杂度为：$O(n^2)$

空间复杂度：

• 压缩前：$O(n^2)$
• 压缩后：$O(n)$

程序代码

未进行状态压缩

class Solution {
public:
    bool isInterleave(string s1, string s2, string s3) {
        int n1 = s1.size(), n2 = s2.size(), m = s3.size();
        if(n1 + n2 != m)  return false;
        vector<vector<bool>> dp(n1 + 1, vector<bool>(n2 + 1, false));

        dp[0][0] = true;

        for(int i = 0; i <= n1; i++) {
            for(int j = 0; j <= n2; j++) {
                int k = i + j - 1;
                if(i > 0)  dp[i][j] = dp[i][j] || (dp[i-1][j] && s1[i-1] == s3[k]);
                if(j > 0)  dp[i][j] = dp[i][j] || (dp[i][j-1] && s2[j-1] == s3[k]);
            }
        }

        return dp[n1][n2];
    }
};

状态压缩后

class Solution {
public:
    bool isInterleave(string s1, string s2, string s3) {
        int n1 = s1.size(), n2 = s2.size(), m = s3.size();
        if(n1 + n2 != m)  return false;
        vector<bool> dp(n2 + 1, false);
        dp[0] = true;
        for(int i = 0; i <= n1; i++) {
            for(int j = 0; j <= n2; j++) {
                int k = i + j - 1;
                if(i > 0)  dp[j] = dp[j] && s1[i-1] == s3[k];
                if(j > 0)  dp[j] = dp[j] || (dp[j-1] && s2[j-1] == s3[k]);
            }
        }

        return dp[n2];
    }
};