给定三个字符串 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

提示：
0 <= s1.length, s2.length <= 100
0 <= s3.length <= 200
s1、s2、和 s3 都由小写英文字母组成

法1:二维数组动态规划

class Solution {
public:
    bool isInterleave(string s1, string s2, string s3) {
        int n1 = s1.size(), n2 = s2.size(), n3 = s3.size();
        if(n1 + n2 != n3){
            return false;
        }
        vector<vector<int>> f(n1+1, vector<int>(n2+1, false));
        f[0][0] = true;
        for(int i = 0; i <= n1; i++){
            for(int j = 0; j <= n2; j++){
                int p = i + j - 1;
                if(i > 0){
                    f[i][j] |= (f[i-1][j] && s1[i-1] == s3[p]);
                }
                if(j > 0){
                    f[i][j] |= (f[i][j-1] && s2[j-1] == s3[p]);
                }
            }
        }
        return f[n1][n2];
    }
};

时间复杂度和空间复杂度都是 O(n1n2)。

这个动态规划的核心思想就是，定义一个动态数组f[i][j]，他的含义是s1的前i个字符和s2的前j个字符是否可以构成s3的前i+j个字符的交叉字符串。

在局部方面，也就是子问题上，我们判断f[i][j]是否能构成true情况：
一种情况是s1的第i个字符等于s3的第i+j个字符时，要保证f[i-1][j]是否也为true，如果两个条件都满足，那么f[i][j]为true。需要注意的是在这里，举个例子，f[1][1]的含义是s1的前1个字符和s2的前一个字符，也就是s1[0]，s2[0]。而s1的第i个字符，在这里就是s1[i-1]。定义一个整型p为i+j-1，用来表示s3的第i+j个字符。

第二种情况同理，也就是s2的第j个字符等于s3的第i+j个字符，这时候也要保证f[i][j-1]也为true，f[i][j]才为true。

以上两种情况有一种成立，则f[i][j]为true。

法2:滚动数组优化

class Solution {
public:
    bool isInterleave(string s1, string s2, string s3) {
        auto f = vector <int> (s2.size() + 1, false);

        int n = s1.size(), m = s2.size(), t = s3.size();

        if (n + m != t) {
            return false;
        }

        f[0] = true;
        for (int i = 0; i <= n; ++i) {
            for (int j = 0; j <= m; ++j) {
                int p = i + j - 1;
                if (i > 0) {
                    f[j] &= (s1[i - 1] == s3[p]);
                }
                if (j > 0) {
                    f[j] |= (f[j - 1] && s2[j - 1] == s3[p]);
                }
            }
        }

        return f[m];
    }
};

时间复杂度：O(nm)，两重循环的时间代价为 O(nm)。
空间复杂度：O(m)，即 s2的长度。

滚动数组的优化，我们观察方法一，可以观察到f[i][j]所需要参考的状态只有上面的f[i-1][j]和左边的f[i][j-1]，所以我们可以使用滚动数组的方式来省略掉i。

我们只需要一个一维的数组f[j]，在计算的时候，f[j] &= (s1[i - 1] == s3[p]);和之前的f[i][j] |= (f[i-1][j] && s1[i-1] == s3[p])含义相同，我们由于已经j+1，这时候的f[j]实际上已经储存着上一行的第j列第信息，也就是之前的f[i-1][j]。

然后由于f[j-1]我们已经计算过，他保存的信息是这一行的j-1列的布尔值，所以我们f[j] |= (f[j - 1] && s2[j - 1] == s3[p])来替代之前的f[i][j] |= (f[i][j-1] && s2[j-1] == s3[p])。

滚动数组在空间上进行了优化，同时也说明了他损失了一些信息，他始终只储存着计算的最新一行的值，由于我们只需要最后一次计算的f[i][j]，所以滚动数组在解决这个问题上是一个有效的优化。