LeetCode 97. 交错字符串--动态规划--区间DP

97. 交错字符串
    给定三个字符串 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 都由小写英文字母组成

题解

可以看出明显的动态规划，老规矩，遇到动态规划，先写递归方程，递归方程写出来如下：

    bool solve(string s1,string s2,string s3,int i,int j,int k)
    {
        if(i==s1.length()&&j==s2.length()&&k==s3.length())
            return true;
        if(i<s1.length()&&j<s2.length()&&k<s3.length()&&s1[i]==s3[k]&&s2[j]==s3[k])
        return solve(s1,s2,s3,i+1,j,k+1)||solve(s1,s2,s3,i,j+1,k+1);
        else if(i<s1.length()&&k<s3.length()&&s1[i]==s3[k])
        return solve(s1,s2,s3,i+1,j,k+1);
        else if(j<s2.length()&&k<s3.length()&&s2[j]==s3[k])
        return solve(s1,s2,s3,i,j+1,k+1);
        return false;
    }
    return solve(s1,s2,s3,0,0,0);//返回答案

上面的代码比较好理解吧，就是最简单直接的暴力搜索方式。于是按照递归函数，我们写出对应的dp方程，定义dp[100][100][200]，dp[i][j][k]表示字符串s1[i:n1]和字符串s2[j:n2]恰好能和字符串s3[k:n3]构成匹配关系。

于是代码如下：

class Solution {
public:
    bool dp[110][110][210];
    bool isInterleave(string s1, string s2, string s3) {
        if(s1==""&&s2==""&&s3=="")return true;
        if(s1=="")return s2==s3?true:false;
        if(s2=="")return s1==s3?true:false;
        if(s1.length()+s2.length()>s3.length())return false;
        memset(dp,0,sizeof(dp));
        //注意初始化
        for(int i=s1.length()-1,k=s3.length()-1;i>=0&&k>=0;i--,k--)
        {
            if(s1[i]==s3[k])
            dp[i][s2.length()][k]=true;   
            else break;         
        }
        for(int j=s2.length()-1,k=s3.length()-1;j>=0&&k>=0;j--,k--)
        {
            if(s2[j]==s3[k])
            dp[s1.length()][j][k]=true;
            else break;
        }
        for(int i=s1.length()-1;i>=0;i--)
        {
            for(int j=s2.length()-1;j>=0;j--)
            {
                for(int k=s3.length()-1;k>=0;k--)
                {
                    if(s1[i]==s3[k]&&s2[j]==s3[k])
                    dp[i][j][k]=dp[i][j][k]||dp[i+1][j][k+1]||dp[i][j+1][k+1];
                    else if(s1[i]==s3[k])
                    dp[i][j][k]=dp[i][j][k]||dp[i+1][j][k+1];
                    else if(s2[j]==s3[k])
                    dp[i][j][k]=dp[i][j][k]||dp[i][j+1][k+1];
                }
            }
        }
        return dp[0][0][0];
    }
};