交错字符串(Java)

题目描述

给定三个字符串 s1, s2, s3, 验证 s3 是否是由 s1 和 s2 交错组成的。

示例

示例1

输入: s1 = “aabcc”, s2 = “dbbca”, s3 = “aadbbcbcac”
输出: true

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

题目链接

递归

将s1或者s2中的第一个字符与s3的第一个字符匹配。只要有一个匹配成功则算s3的这个字符成功匹配。若是匹配成功则丢弃这个匹配过的字符，然后继续匹配。直到s3的长度为0，即所有s3所有字符都被匹配掉了。

    public boolean isInterleave(String s1, String s2, String s3) {
        if (s1.length() + s2.length() != s3.length())
            return false;
        if (s3.length() == 0)
            return true;
        boolean machLeft = false;
        if (s1.length() > 0) {
            if (s1.charAt(0) == s3.charAt(0))
                machLeft = isInterleave(s1.substring(1), s2, s3.substring(1));
        }
        boolean machRight = false;
        if (s2.length() > 0) {
            if (s2.charAt(0) == s3.charAt(0))
            machRight = isInterleave(s1, s2.substring(1), s3.substring(1));
        }
        return machLeft || machRight;
    }

以上代码计算结果是正确的，但是时间复杂度很高，做了许多重复的计算。那么如何减少重复的计算呢？本人的做法是用一个二维数组保存匹配过的结果。dp[i][j]的元素表示s1的前i个字符和s2的前j个字符是否能够成功匹配s3中的前i+j个字符。dp[i][j]=1表示匹配成功，dp[i][j]=-1表示匹配失败。

递归优化

 public static boolean isInterleave(String s1, String s2, String s3) {
        int[][] dp = new int[s1.length() + 1][s2.length() + 1];
        return helper(s1, s2, s3, dp, 0, 0);
    }

    private static boolean helper(String s1, String s2, String s3, int[][] dp, int i, int j) {
        if (s1.length() + s2.length() != s3.length() || dp[i][j] == -1)
            return false;
        if (s3.length() == 0 || dp[i][j] == 1)
            return true;
        boolean machLeft = false, machRight = false;
        if (s1.length() > 0) {
            if (s1.charAt(0) == s3.charAt(0)) {
                machLeft = helper(s1.substring(1), s2, s3.substring(1), dp, i + 1, j);
                dp[i + 1][j] = machLeft ? 1 : -1;
            }
        }
        if (s2.length() > 0) {
            if (s2.charAt(0) == s3.charAt(0)) {
                machRight = helper(s1, s2.substring(1), s3.substring(1), dp, i, j + 1);
                dp[i][j + 1] = machRight ? 1 : -1;
            }
        }
        boolean result = machLeft || machRight;
        dp[i][j] = result ? 1 : -1;
        return result;
    }

这样，递归优化完毕。效率还不错

动态规划

其实在之前的递归优化里已经有动态规划的端倪了。dp[i][j]的元素表示s1的前i个字符和s2的前j个字符是否能够成功匹配s3中的前i+j个字符.默认空串匹配成功，即dp[0][0]=0。dp[i][j]由dp[i-1][j]或者dp[i][j-1]转移而来。

  public static boolean isInterleaveDP(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 = 0; i < s1.length(); i++) {
            for (int j = 0; j < s2.length(); j++) {
                int k=i+j-1;
                if (i>0){
                    dp[i][j]=dp[i-1][j] && s1.charAt(i)==s3.charAt(k);
                }
                if (j>0){
                    dp[i][j]=dp[i][j] ||(dp[i][j-1]&& s2.charAt(j)==s3.charAt(k));
                }
            }
        }
     return dp[s1.length()][s2.length()];
    }

答案正确，但是效率还算不得让人满意。