leetcode-Interleaving String

Given s1, s2, s3, find whether s3 is formed by the interleaving of s1 and s2.

For example,
Given:
s1 = "aabcc",
s2 = "dbbca",

When s3 = "aadbbcbcac", return true.
When s3 = "aadbbbaccc", return false.

这道题需要判断两个字符串能否合并组成另外一个新的字符串，这个合并是有序的合并，就是在新的字符串中，可以分别找到跟原来两个字符串，并且字母的顺序跟原两个字符串字母顺序是一致的。

假设s1长度为n1, s2长度为n2，那么s3的每个字母都有2种选择，即s3的第一个字母可以从s1开头取，也可以从s2开头取，这样一共要从s1和s2中取(n1+n2)个数，总共s3可能数为从n1+n2中取n1个.

这里是要判断s3是否可以由s1和s2有序合并。容易想到用递归来求解，比较s3的第一个字母与s1和s2的第一个字母，如果s3[0]=s1[0],说明s3的第一个数可以从s1取，这样要继续搜索s3后面的字符串能否用s1的第一个字母后的字符串和s2拼成;如果s3[0]=s2[0],说明s3的第一个数也可以从s2取，然后继续搜索s3后面字符串能否用s1和s2第一个字母后字符串拼成。这样递归下去是可以算出答案的。

所以编个简单的递归如下：

class Solution {
public:
    bool isInterleave(string s1, string s2, string s3) {
        if (s3.size() != s1.size()+s2.size())
            return false;
        return isInterleave(s1, 0, s2, 0, s3, 0);
    }
private:
    bool isInterleave(const string &s1, int b1, const string &s2, int b2, 
         const string& s3, int b3) {
        if (b1 == s1.size())   // s1 reaches end
            return s3.substr(b3) == s2.substr(b2);
        
        if (b2 == s2.size())   // s2 reaches end
            return s3.substr(b3) == s1.substr(b1);
        
         if (s3[b3] == s1[b1]) { //match s1
             if (isInterleave(s1, b1+1, s2, b2, s3, b3+1))
                 return true;
         }
         
         if (s3[b3] == s2[b2]) { //match s2
            if (isInterleave(s1, b1, s2, b2+1, s3, b3+1))
                return true;
         }
        
        return false;  // no match
    }
};

最终结果是TLE。因为上面的递归计算了很多重复的子任务，所以改成记忆化搜索如下：

class Solution {
public:
    bool isInterleave(string s1, string s2, string s3) {
        if (s3.size() != s1.size()+s2.size())
            return false;
        memset(hasSearched, false, sizeof(hasSearched));
        return isInterleave(s1, 0, s2, 0, s3, 0);
    }
private:
    bool isInterleave(const string &s1, int b1, const string &s2, int b2, 
         const string& s3, int b3) {
        if (b1 == s1.size())   // s1 reaches end
            return s3.substr(b3) == s2.substr(b2);
        
        if (b2 == s2.size())   // s2 reaches end
            return s3.substr(b3) == s1.substr(b1);
        
         if (s3[b3] == s1[b1]) { //match s1
             if (!hasSearched[b1+1][b2] && isInterleave(s1, b1+1, s2, b2, s3, b3+1))
                 return true;
         }
         
         if (!hasSearched[b1][b2+1] && s3[b3] == s2[b2]) { //match s2
            if (isInterleave(s1, b1, s2, b2+1, s3, b3+1))
                return true;
         }
        
        hasSearched[b1][b2] = true;
        return false;  // no match
    }
    
    bool hasSearched[100][100];
};

也还可以再继续优化，比如检测到s3字符与s1字符相等时，可以先行判断s3后面的一个字符是否与s1、s2的前面字符相等，如果不等，这条路径就不必走下去了。

其实也可以用动态规划求解。

class Solution {
public:
    bool isInterleave(string s1, string s2, string s3) {
        if (s3.size() != s1.size()+s2.size())
            return false;
            
        bool d[200][200] = {false};    // d[i][j]表示s1的前i个字符和s2的前j个字符能否组成s3的前i+j个字符
        d[0][0] = true;   
            
        int len1=s1.size(), len2=s2.size();
        
        for (int i=0; i<=len1; ++i) {
            for (int j=0; j<=len2; j++) {
                
                if (s1[i]==s3[i+j] && d[i][j]==true) 
                    d[i+1][j] = true;
                
                if (s2[j]==s3[i+j] && d[i][j]==true)
                    d[i][j+1] = true;
            }
        }
        
        return d[len1][len2];
    }
    
};