leetcode_97_交错字符串

题目：

给定三个字符串 s1, s2, s3, 验证 s3 是否是由 s1 和 s2 交错组成的。

示例 1:

输入: s1 = "aabcc", s2 = "dbbca", s3 = "aadbbcbcac"
输出: true
示例 2:

输入: s1 = "aabcc", s2 = "dbbca", s3 = "aadbbbaccc"
输出: false

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/interleaving-string
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

---

思路：

首先尝试了使用DFS解决，果不其然的超时了555。。。

原因在于：搜索的过程中，没有将中间状态记住，比如在搜索匹配S3[i->j]时，本来S3[k->j]上次已经搜索过并且已经可以确定是否匹配，
但是由于并未记住状态，所以相当于重复计算。所以超时。。。。

然后想到动态规划。。。（最近动态规划有点多。。。）。

先定义：

①dp[i][j]表示截止到S1的i下标处、S2的j下标处时，总匹配情况。（很明显此时S3一定是匹配到下标i+j处）。

②len1表示字符串S1的长度，len2表示字符串S2的长度，len3表示字符串S3的长度。

策略：

如果len1+len2 != len3，很明显，直接可以返回false。

对于dp[i][j]：

①如果S1[i] == S3[i+j]，则此时的dp[i][j]很明显取决于dp[i-1][j]，即在这种情况下如果dp[i-1][j]是True，那么dp[i][j]也一定就是true。因为当前的S1[i]于S3[i+j]处的字符相等。

②如果S2[j] == S3[i+j]，则此时的dp[i][j]很明显也取决于dp[i][j-1]。此时和情况①一样，不再过多解释。。。

经上分析可得：

dp[i][j] = (dp[i-1][j] && S1[i]==S3[i+j])  ||  (dp[i][j-1] && S2[j]==S3[i+j])

这就是DP过程中的状态转移方程了。

Note：根据dp[i][j]的定义，很明显的需要将dp[0][0]初始化为true。其他的初始化为false。

---

实现：

JAVA版（DFS实现和DP实现都有。555）：

package leetcode;

/*
USER：LQY
DATE：2020/7/18
TIME：9:31
*/
public class leetcode_97 {

    public static void main(String []args){
        String s1 = "a";
        String s2 = "";
        String s3 = "a";

        System.out.println(new leetcode_97().isInterleave2(s1, s2, s3));
    }
    public boolean isInterleave2(String s1, String s2, String s3){
        int len1 = s1.length();
        int len2 = s2.length();
        int len3 = s3.length();
        if(len3 != len1+len2) return false;
        if(len3 == 0) return true;
        boolean [][]dp = new boolean[len1+1][len2+1];
        dp[0][0] = true;

        for(int i = 0;i <= len1;i++){
            for(int j = 0;j <= len2;j++){
                boolean tb = dp[i][j];
                if(i > 0){
                    tb = tb || (s1.charAt(i-1)==s3.charAt(i+j-1));
                }
                if(j > 0){
                    tb = tb || (s2.charAt(j-1)==s3.charAt(i+j-1));
                }
                dp[i][j] = tb;
            }
        }

        return dp[len1][len2];
    }

    public boolean isInterleave(String s1, String s2, String s3) {
        int len1 = s1.length();
        int len2 = s2.length();
        int len3 = s3.length();
        if(len3 != len1+len2) return false;
        boolean []dp = new boolean[len3];
        int index1 = 0;
        int index2 = 0;
//        solve(s1, s2, s3, index1, index2, 0, dp);
        for(boolean d : dp)
            System.out.print(d+" ");
        System.out.println();
        return dp[len3-1];
    }

    //这种深度搜索的方法可以解决绝大多数的测试用例。
//    但是还是无法AC。会超时。
//    原因在于：搜索的过程中，没有将中间状态记住，比如在搜索匹配S3[i->j]时，本来S3[k->j]上次已经搜索过并且已经可以确定是否匹配，
//    但是由于并未记住状态，所以相当于重复计算。所以超时。。。。
    public boolean solve(String s1, String s2, String s3, int index1, int index2, int i, boolean []dp){
        if(index1 >= s1.length()){
            while(i < s3.length()){
                if(s3.charAt(i) != s2.charAt(index2))
                    return false;
                dp[i] = true;
                i++;
                index2++;
            }
            return true;
        }else if(index2 >= s2.length()){
            while(i < s3.length()){
                if(s3.charAt(i) != s1.charAt(index1))
                    return false;
                dp[i] = true;
                i++;
                index1++;
            }
            return true;
        }else{
            char c1 = s1.charAt(index1);
            char c2 = s2.charAt(index2);
            char c3 = s3.charAt(i);
            if(c3==c1 && c3==c2){
                dp[i] = solve(s1, s2, s3, index1+1, index2, i+1, dp) || solve(s1, s2, s3, index1, index2+1, i+1, dp);
            }else if(c3 == c1){
                dp[i] = i>=1? dp[i-1]:true;
                solve(s1, s2, s3, index1+1, index2, i+1, dp);
            }else if(c3 == c2){
                dp[i] = i>=1? dp[i-1]:true;
                solve(s1, s2, s3, index1, index2+1, i+1, dp);
            }else{
                return false;
            }
            return dp[i];
        }
    }
}

C++版：

class Solution {
public:
    bool isInterleave(string s1, string s2, string s3) {
        int len1 = s1.length();
        int len2 = s2.length();
        int len3 = s3.length();
        if(len1+len2 != len3) return false;
        if(len3 == 0) return true;

        bool dp[len1+1][len2+1];
        for(int i = 0;i <= len1;i++)
            for(int j = 0;j <= len2;j++)
                dp[i][j] = false;
        dp[0][0] = true;

        for(int i = 0;i <= len1;i++){
            for(int j = 0;j <= len2;j++){
                bool tb = dp[i][j];
                if(i > 0){
                    tb = tb || (dp[i-1][j] && (s1[i-1]==s3[i+j-1]));
                }
                if(j > 0){
                    tb = tb || (dp[i][j-1] && (s2[j-1]==s3[i+j-1]));
                }
                dp[i][j] = tb;
            }
        }
        return dp[len1][len2];
    }
};