LeetCode刷题——交错字符串#97#Medium

交错字符串的思路探讨与源码
     交错字符串的题目如下图，该题属于字符串和动态规划类型的题目，主要考察对于动态规划方法的使用和字符串本身特性的理解。本文的题目作者想到2种方法，分别是动态规划方法和DFS深度优先搜索方法，其中动态规划方法使用Java进行编写，而DFS深度优先搜索方法使用Python进行编写，当然这可能不是最优的解法，还希望各位大佬给出更快的算法。

    本人认为该题目可以使用动态规划方法解决，首先计算字符串的长度，直接将三个字符串进行比较，如果前两个的长度和第三个字符串的长度不相等，那么直接返回false结果。然后初始化动态规划二维数组，并且将第一个元素设置为true的结果，并且开始对字符串1和字符串2进行循环遍历，按照动态规划方程进行操作。
matrix(ir,jr)=[matrix(ir-1,jr) and s1(ir-1)=s3(index)] or [matrix(ir,jr-1) and s2(jr-1)=s3(index)]
并且最终返回结果。那么按照这个思路我们的Java代码如下：

#喷火龙与水箭龟
class Solution {
    public boolean isInterleave(String s1, String s2, String s3) {
        int lenS1 = s1.length();
        int lenS2 = s2.length();
        int lenS3 = s3.length();
        if (lenS3 != (lenS1+lenS2)) {
            return false;
        }
        boolean[][] matrix = new boolean[lenS1+1][lenS2+1];
        matrix[0][0] = true;
        for (int ir = 0; ir <= lenS1; ir++) {
            for (int jr = 0; jr <= lenS2; jr++) {
                int index = ir + jr - 1;
                if (ir > 0) {
                    boolean b1 = matrix[ir - 1][jr] && s1.charAt(ir - 1) == s3.charAt(index);
                    matrix[ir][jr] = matrix[ir][jr] || b1;
                }
                if (jr > 0) {
                    boolean b2 = matrix[ir][jr - 1] && s2.charAt(jr - 1) == s3.charAt(index);
                    matrix[ir][jr] = matrix[ir][jr] || b2;
                }
            }
        }
        return matrix[lenS1][lenS2];
    }
}

    显然，我们看到动态规划方法的效果还不错，同时还可以使用DFS深度优先搜索方法，首先计算三个字符串的长度，判断字符串1加上字符串2是否和字符串3相等，如果不相等则直接返回False的结果。然后初始化缓存，并且定义深度优先搜索方法的函数，在函数内部先设置终止条件，然后分别对字符串1和字符串2的下标做判断条件的设置，如果到最后还没有结束就直接返回False的结果。并且从三个字符串的第一个元素开始调用深度优先搜索函数，直到最终结束。所以按照这个思路就可以解决，下面是Python代码部分：

#喷火龙与水箭龟
class Solution:
    def isInterleave(self, s1: str, s2: str, s3: str) -> bool:
        s1Len = len(s1)
        s2Len = len(s2)
        s3Len = len(s3)
        if s3Len != (s1Len+s2Len):
            return False
        @lru_cache()
        def searchDFS(ir,jr,kr):
            if ir == s1Len and jr == s2Len and kr == s3Len:
                return True
            if ir > s1Len or jr > s2Len or kr > s3Len:
                return False
            if ir < s1Len and kr < s3Len and s1[ir] == s3[kr] and searchDFS(ir+1,jr,kr+1):
                return True
            if jr < s2Len and kr < s3Len and s2[jr] == s3[kr] and searchDFS(ir,jr+1,kr+1):
                return True
            return False
        return searchDFS(0, 0, 0)        

    从结果来说Java版本的动态规划方法的效率还不错，而Python版本的DFS深度优先搜索方法的速度也还可以，但应该是有更多的方法可以进一步提速的，希望朋友们能够多多指教，非常感谢。