交错字符串。 有三个字符串s1,s2,s3。判断s3是否由s1和s2交错组成的。比如s1=“abc”,s2=“123”,s3=“12ab3c”，应该返回true，因为s3去掉123后，剩下的是abc。比如s1=“abc”,s2=“123”,s3=“12ba3c”，应该返回false，因为s3去掉123后，剩下的是bac，顺序不一致，不符合条件。

方法一：双指针。表面上可以用这种方法，实际上是不对的。如果回溯，那跟方法二就没区别了，这种方法直接舍弃。

方法二：动态规划，样本对应模型。
dp[i][j]依赖左边和上边。
根据下面的动态规划表格可以看出规律：左对看上等，上对看左等。
状态转移方程我不懂，就不说了。
时间复杂度：O(MN)。
空间复杂度：O(MN)。可优化成O(M)。

代码用golang编写。代码如下：

package main

import "fmt"

func main() {
    s1 := "aaabsk"
    s2 := "aacfk"
    s3 := "aaacaabfskk"
    ret := isInterleave(s1, s2, s3)
    fmt.Println(ret)
}

func isInterleave(s1 string, s2 string, s3 string) bool {
    if len(s3) != (len(s1) + len(s2)) {
        return false
    }
    dp := make([][]bool, len(s1)+1)
    for i := 0; i < len(s1)+1; i++ {
        dp[i] = make([]bool, len(s2)+1)
    }
    dp[0][0] = true
    for i := 1; i <= len(s1); i++ {
        if s1[i-1] != s3[i-1] {
            break
        }
        dp[i][0] = true
    }
    for j := 1; j <= len(s2); j++ {
        if s2[j-1] != s3[j-1] {
            break
        }
        dp[0][j] = true
    }
    for i := 1; i <= len(s1); i++ {
        for j := 1; j <= len(s2); j++ {
            if s1[i-1] == s3[i+j-1] && dp[i-1][j] || s2[j-1] == s3[i+j-1] && dp[i][j-1] {
                dp[i][j] = true
            }
        }
    }
    return dp[len(s1)][len(s2)]
}

执行结果如下：

动态规划图解如下：