leetcode-97. 交错字符串

题目

链接：https://leetcode-cn.com/problems/interleaving-string
给定三个字符串 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 连接。

示例 1：
输入：s1 = “aabcc”, s2 = “dbbca”, s3 = “aadbbcbcac”
输出：true

示例 2：
输入：s1 = “aabcc”, s2 = “dbbca”, s3 = “aadbbbaccc”
输出：false

示例 3：
输入：s1 = “”, s2 = “”, s3 = “”
输出：true

解题思路一

每次比较s1/s2的第一个字符与s3是否相等，如果相等，则继续递归比较后续的字符串。
分为4种情况：

• s1和s3第一个字符相等，则继续比较s1、s3去掉第一个字符的情况。
• s2和s3第一个字符相等，则继续比较s2、s3去掉第一个字符的情况。
• s1/s2都和s3的第一个字符相等，则继续比较s2、s3以及s1、s3去掉第一个字符的情况。
• 如果s1、s2都和s3不相等，返回false

解题代码

public boolean isInterleave(String s1, String s2, String s3) {
    //  长度不相等，直接不通过
    if (s1.length() + s2.length() != s3.length()) {
        return false;
    }
    // 如果s2是空字符，则说明s1要等于s3
    if (Objects.equals(s2, "")) {
        return Objects.equals(s3, s1);
    }
    // 如果s1是空，则s2等于s3
    if (Objects.equals(s1, "")) {
        return Objects.equals(s3, s2);
    }
    // 每次比对第一个字符
    char s1Char = s1.charAt(0);
    char s2Char = s2.charAt(0);
    char s3Char = s3.charAt(0);
    if (s1Char != s3Char && s2Char != s3Char) {
        return false;
    }
    // 如果s1、s2的第一个字符都满足，则需要返回2种情况
    if (s1Char == s3Char && s2Char == s3Char) {
        return isInterleave(s1.substring(1), s2, s3.substring(1)) || isInterleave(s1, s2.substring(1),
                s3.substring(1));
    }
    // 其余递归比对即可
    if (s1Char == s3Char) {
        return isInterleave(s1.substring(1), s2, s3.substring(1));
    }
    return isInterleave(s1, s2.substring(1), s3.substring(1));
}

提交结果

99 / 106 个通过测试用例，状态：超出时间限制

优化代码

由于这里每次从下一个字符开始比较，由于字符串是final的，所以切割字符串会造成每次都需要去创建一个新字符串对象，导致部分效率被浪费，其实可以使用通过每次更新需要比较的下标去进行比较，不必要切割字符串。

public boolean isInterleave(String s1, String s2, String s3) {
    //  长度不相等，直接不通过
    if (s1.length() + s2.length() != s3.length()) {
        return false;
    }
    return isInterleaveDFS(s1, s2, s3, 0, 0, 0);
}

private boolean isInterleaveDFS(String s1, String s2, String s3, int s1Index, int s2Index, int s3Index) {
    // 如果s2是空字符，则说明s1要等于s3
    if (s2Index >= s2.length()) {
        return Objects.equals(s3.substring(s3Index), s1.substring(s1Index));
    }
    // 如果s1是空，则s2等于s3
    if (s1Index >= s1.length()) {
        return Objects.equals(s3.substring(s3Index), s2.substring(s2Index));
    }
    // 每次比对第一个字符
    char s1Char = s1.charAt(s1Index);
    char s2Char = s2.charAt(s2Index);
    char s3Char = s3.charAt(s3Index);
    if (s1Char != s3Char && s2Char != s3Char) {
        return false;
    }
    // 如果s1、s2的第一个字符都满足，则需要返回2种情况
    if (s1Char == s3Char && s2Char == s3Char) {
        return isInterleaveDFS(s1, s2, s3, s1Index + 1, s2Index, s3Index + 1) || isInterleaveDFS(s1, s2, s3,
                s1Index,
                s2Index + 1, s3Index + 1);
    }
    // 其余递归比对即可
    if (s1Char == s3Char) {
        return isInterleaveDFS(s1, s2, s3, s1Index + 1, s2Index, s3Index + 1);
    }
    return isInterleaveDFS(s1, s2, s3, s1Index, s2Index + 1, s3Index + 1);
}

提交结果

105 / 106 个通过测试用例，状态：超出时间限制

至此递归去深度遍历无法处理该题目，改为使用动态规划。

解题思路二

这里每次遍历s1或s2的字符去进行s3的进行比较，都可以记为前面的是否可以转换成s3的一部分和当前字符与s3的是否相等的结果。

所以这里有dp[0] = true，dp[i] = dp[i-1] && s3 == s1[i-1]，s2同理。

再根据后续的字符交叉比较，都可以转换成以下dp表达式，本质就是把字符串比较保存结果在dp[i][j]，分别表示的是上一个字符是s1的第i-1个字符和s2的第j-1个字符，因此最后结果返回应该是dp[i][j]。

dp[i][j]=dp[i-1][j] && s1[i-1]===s3[i-1+j] || dp[i][j-1] && s2[j-1] == s3[i-1+j]

代码如下

public boolean isInterleave(String s1, String s2, String s3) {
    //  长度不相等，直接不通过
    if (s1.length() + s2.length() != s3.length()) {
        return false;
    }
    boolean[][] dp = new boolean[s1.length() + 1][s2.length() + 1];
    dp[0][0] = true;
    for (int i = 1; i <= s1.length(); i++) {
        dp[i][0] = dp[i - 1][0] && s3.charAt(i - 1) == s1.charAt(i - 1);
    }
    for (int i = 1; i <= s2.length(); i++) {
        dp[0][i] = dp[0][i - 1] && s3.charAt(i - 1) == s2.charAt(i - 1);
    }
    for (int i = 1; i <= s1.length(); i++) {
        for (int j = 1; j <= s2.length(); j++) {
            dp[i][j] = (dp[i - 1][j] && s1.charAt(i - 1) == s3.charAt(i - 1 + j))
                    || (dp[i][j - 1] && s2.charAt(j - 1) == s3.charAt(i - 1 + j));
        }
    }
    return dp[s1.length()][s2.length()];
}

提交结果

执行结果：通过 执行用时：5 ms