Leetcode:Interleaving String 解题报告

Interleaving String
Given s1, s2, s3, find whether s3 is formed by the interleaving of s1 and s2.

For example,
Given:
s1 = "aabcc",
s2 = "dbbca",

When s3 = "aadbbcbcac", return true.
When s3 = "aadbbbaccc", return false.

题解：
到了HARD难度了，主页君好兴奋啊！啦啦啦

让我们来逐层分解DP吧！

其实DP的本质是Bottom -- UP的解决方法，先解决小的子问题，再一步一步解决大的问题，而递归是TOP-DOWN的解决方案。一开始就想最顶层的解决方案，通过递归来一层层分解成小的子问题。

今天我们来探讨一下本题的3种解法
1. Brute Force的递归解法。
index1, index2, index3分别代表s1,s2,s3三个字符串的起始地址（就是从哪里开始判断）
判断s1, s2, s3是否是Interleaving String 应该这样判断：
（1）. s3的首字母是来自s1吗？如果是，可以拆解为s1的 index1+1 与 s2 index2 与s3的Interleaving String子问题。
（2）. s3的首字母是来自s2吗？如果是，可以拆解为s2的 index2+1 与 s1 index1 与s3的Interleaving String子问题。
以上2个条件成立一个，表示我们的结果是成立。
Base Case:
如果index3 超过了s3的length，表示s3是空串，这时应返回TRUE

代码主页君没有写，可以参考第二个解法Brute Force 带Memory的解法，只需要把最后一个memory的参数拿走就可以了。

如果直接这样写Leetcode是time limited.

2. 递归加记忆矩阵的解法。
与1的思路完全一致，但是我们加一个二维矩阵来记录结果值，这样可以减少不必要的重复计算. 这样下来速度与DP会完全一致，也可以通过Leetcode的检查

// Solution1: Recursion with memory
    public static boolean isInterleave1(String s1, String s2, String s3) {
        if (s1 == null || s2 == null || s3 == null) {
            return false;
        }

        int len1 = s1.length();
        int len2 = s2.length();
        int len3 = s3.length();

        // The length is not equal, just return false.
        if (len1 + len2 != len3) {
            return false;
        }

        int[][][] memory = new int[len1 + 1][len2 + 1][len3 + 1];
        for (int i = 0; i <= len1; i++) {
            for (int j = 0; j <= len2; j++) {
                for (int k = 0; k <= len3; k++) {
                    memory[i][j][k] = -1;
                }
            }
        }

        return recMemory(s1, 0, s2, 0, s3, 0, memory);
    }

    public static boolean recMemory(String s1, int index1, String s2,
            int index2, String s3, int index3, int[][][] memory) {
        int len1 = s1.length();
        int len2 = s2.length();
        int len3 = s3.length();

        if (index3 == len3 && index1 == len1 && index2 == len2) {
            return true;
        }

        if (memory[index1][index2][index3] != -1) {
            return memory[index1][index2][index3] == 1;
        }

        // 第一个字符，有2种可能：来自s1, 或是来自s2
        boolean ret = false;
        if (index1 < len1 && s1.charAt(index1) == s3.charAt(index3)) {
            ret = recMemory(s1, index1 + 1, s2, index2, s3, index3 + 1, memory);
        }

        // 如果不成功(首字母不来自于s1)，尝试另一种可能
        if (!ret && index2 < len2 && s2.charAt(index2) == s3.charAt(index3)) {
            ret = recMemory(s1, index1, s2, index2 + 1, s3, index3 + 1, memory);
        }

        memory[index1][index2][index3] = ret ? 1 : 0;
        return ret;
    }

    // Solution2: Recursion with memory
    // 思考了一下看了一下过去的代码，发现其实我们用不到三维数组，因为len1 + len2 = len3,
    // 所以第三维根本可以省略嘛
    public static boolean isInterleave2(String s1, String s2, String s3) {
        if (s1 == null || s2 == null || s3 == null) {
            return false;
        }

        int len1 = s1.length();
        int len2 = s2.length();
        int len3 = s3.length();

        // The length is not equal, just return false.
        if (len1 + len2 != len3) {
            return false;
        }

        int[][] memory = new int[len1 + 1][len2 + 1];
        for (int i = 0; i <= len1; i++) {
            for (int j = 0; j <= len2; j++) {
                memory[i][j] = -1;
            }
        }

        return recMemory2(s1, 0, s2, 0, s3, 0, memory);
    }

3. DP

D[i][j]: 定义为s1 (前i个字符) s2(前j个字符) s3(i+j 个字符) 是不是交叉字符
递推公式： (s1.i == s3.(i+j) && D[i-1][j]) || (s2.j == s3.(i+j) && D[i][j - 1])
 分别从s1,s2两种可能性来匹配 ，两者有一个成立就行了。
            s1 s3 首字母相同，继续查i -1 与 i + j -1 是否isInterleave1
            s2 s3 首字母相同，继续查j -1 与 i + j -1 是否isInterleave1

初始化：D 0,0 就是true，因为都是空.
D[0][j] 就是判断一下str2与str3是不是尾字符相同，及D[0][j - 1]是不是true
D[i][0] 就是判断一下str1与str3是不是尾字符相同，及D[i - 1][0]是不是true

public class Solution {
    public boolean isInterleave1(String s1, String s2, String s3) {
        if (s1 == null || s2 == null || s3 == null) {
            return false;
        }
        
        int len1 = s1.length();
        int len2 = s2.length();
        int len3 = s3.length();
        
        if (len1 + len2 != len3) {
            return false;
        }
        
        boolean[][] D = new boolean[len1 + 1][len2 + 1];
        
        for (int i = 0; i <= len1; i++) {
            for (int j = 0; j <= len2; j++) {
                D[i][j] = false;
                if (i == 0 && j == 0) {
                    D[i][j] = true;
                } else if (i == 0) {
                    D[i][j] = s2.charAt(j - 1) == s3.charAt(i + j - 1) && D[i][j - 1];
                } else if (j == 0) {
                    D[i][j] = s1.charAt(i - 1) == s3.charAt(i + j - 1) && D[i - 1][j];
                } else {
                    D[i][j] |= s2.charAt(j - 1) == s3.charAt(i + j - 1) && D[i][j - 1];
                    D[i][j] |= s1.charAt(i - 1) == s3.charAt(i + j - 1) && D[i - 1][j];
                }
            }
        }
        
        return D[len1][len2];
    }
    
    public boolean isInterleave(String s1, String s2, String s3) {
        if (s1 == null || s2 == null || s3 == null) {
            return false;
        }
        
        int len1 = s1.length();
        int len2 = s2.length();
        int len3 = s3.length();
        
        if (len1 + len2 != len3) {
            return false;
        }
        
        boolean[][] D = new boolean[len1 + 1][len2 + 1];
        
        for (int i = 0; i <= len1; i++) {
            for (int j = 0; j <= len2; j++) {
                D[i][j] = false;
                if (i == 0 && j == 0) {
                    D[i][j] = true;
                    continue;
                }
                
                if (i != 0) {
                    D[i][j] |= s1.charAt(i - 1) == s3.charAt(i + j - 1) && D[i - 1][j];
                }
                
                if (j != 0) {
                    D[i][j] |= s2.charAt(j - 1) == s3.charAt(i + j - 1) && D[i][j - 1];
                }
            }
        }
        
        return D[len1][len2];
    }
}

总结：同学在面试的时候，可以尝试写一个递归，然后根据当前问题的规模（比如我们现在是有2个字符串的不同长度组合），那么就可以创建一个二维矩阵来记录结果，加在递归上就能轻松减少复杂度。本题DP/带记忆的递归都是N^2的复杂度。

如果面试官进一步问，你可以根据前面递归的思路，推一个DP公式出来。这个多练几遍很快就会熟悉了。

最后上代码：
GitHub代码链接