Interleaving String -- leetcode

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[i]和s2[j]之前的字符，和s3[i+j+1]之前的字符，已经满足interleave条件，则添加新字符是否能组成新的interleave的条件为：

若 s1[i] == s3[i+j+1]  或者 s2[j] == s3[i+j+1]

class Solution {
public:
    bool isInterleave(string s1, string s2, string s3) {
        return helper(s1.data(), s2.data(), s3.data());
    }
    
    bool helper(const char *s1, const char *s2, const char *s3) {
        if (!*s3) return !*s1 && !*s2;
        
        return *s1 == *s3 && helper(s1+1, s2, s3+1) ||
               *s2 == *s3 && helper(s1, s2+1, s3+1);
    }
};

但是简单递归，时间是却无法被AC。如下面的这样的case:

s1 = "bbbbbabbbbabaababaaaabbababbaaabbabbaaabaaaaababbbababbbbbabbbbababbabaabababbbaabababababbbaaababaa",

s2 = "babaaaabbababbbabbbbaabaabbaabbbbaabaaabaababaaaabaaabbaaabaaaabaabaabbbbbbbbbbbabaaabbababbabbabaab",

s3  ="babbbabbbaaabbababbbbababaabbabaabaaabbbbabbbaaabbbaaaaabbbbaabbaaabababbaaaaaabababbababaababbababbbababbbbaaaabaabbabbaaaaabbabbaaaabbbaabaaabaababaababbaaabbbbbabbbbaabbabaabbbbabaaabbababbabbabbab"

稍微改进了一下，加入访问标志。这下运行时间也能被AC了。下面代码在leetcode上实际执行时间为5ms。

visited访问标志，表示，该对位置(s1,s2)，是否已经被判断过，如果已经判断过。则说明从该位置继续下去没有意义。因为如果行，则早就成功了。

注，虽然地址是64bit的，但由于字符串是连续的。所以用低32bit，足已代表该地址。

class Solution {
public:
    bool isInterleave(string s1, string s2, string s3) {
        unordered_set<uint64_t> visited;
        return helper(s1.data(), s2.data(), s3.data(), visited);
    }
    
    bool helper(const char *s1, const char *s2, const char *s3, unordered_set<uint64_t> &visited) {
        if (!*s3) return !*s1 && !*s2;
        const uint64_t xy = (uint64_t)s1 << 32 | ((uint64_t)s2 & 0xffffffff);
        if (visited.find(xy) != visited.end()) return false;
        visited.insert(xy);
        return *s1 == *s3 && helper(s1+1, s2, s3+1, visited) ||
               *s2 == *s3 && helper(s1, s2+1, s3+1, visited);
    }
};

算法二：

dp[i][j]表示， s1的[0,i]子串，s2的[0,j]的子串，是否能满足s3的[0, i+j+1]子串的interleave关系。

要求出dp[i][j]，需要 dp[i-1][j] 和 dp[i][j-1]两个历史信息。

即: dp[i][j] = dp[i-1][j] && s1[i] == s3[i+j+1] || dp[i][j-1] && s2[j] == s3[i+j+1];

需要一个二维的数组做辅助空间。

但是，由于所需的历史信息，其实是当前的列的前一行，以及当前的行的前一列。 即正上和正左。

这样的情况，可以用滚动数组，去代替二维数组。

即，只需要保留上一行的信息，以及前一列的信息。

故只需要一维数组就行了。 为进一步进省内存，可以选择较短字符的长度作为辅助空间。

class Solution {
public:
    bool isInterleave(string s1, string s2, string s3) {
        if (s1.size() + s2.size() != s3.size())
            return false;
        if (s2.size() > s1.size())
            s2.swap(s1);
        
        vector<char> dp(s2.size()+1);
        dp[0] = 1;
        for (int j=0; j<s2.size(); j++)
            dp[j+1] = dp[j] && s2[j] == s3[j];
            
        for (int i=0; i<s1.size(); i++) {
            dp[0] = dp[0] && s1[i] == s3[i];
            for (int j=0; j<s2.size(); j++) {
                dp[j+1] = dp[j] && s2[j] == s3[i+j+1] || dp[j+1] && s1[i] == s3[i+j+1];
            }
        }
        return dp[s2.size()];
    }
};

算法三：宽度优先搜索

假如 s1 = "aab" and s2 = "abc". s3 = "aaabcb". s1和s2可以组成一个棋盘，或者晶格。如下：

问题就可以转变成，从左上角，到右下角，寻找一条路径，使得路径所经过的字符为s3。

路径上，每一步，只能向右或者向下。

而广度优先搜索，是非常适合处理该问题的。

o--a--o--b--o--c--o
|     |     |     |
a     a     a     a
|     |     |     |
o--a--o--b--o--c--o
|     |     |     |
a     a     a     a
|     |     |     |
o--a--o--b--o--c--o
|     |     |     |
b     b     b     b
|     |     |     |
o--a--o--b--o--c--o

该代码在leetcode上实际执行时间为5ms。

class Solution {
public:
    bool isInterleave(string s1, string s2, string s3) {
        if (s1.size() + s2.size() != s3.size()) return false;
        unordered_set<uint64_t> visited;
        queue<uint64_t> q;
        q.push(0);
        q.push(-1);
        int level = 0;
        while (!(q.size() == 1 && q.front() == -1)) {
            const auto xy = q.front();
            q.pop();
            const uint64_t x = xy & 0xffffffff;
            const uint64_t y = xy >> 32;
            if (x == s1.size() && y == s2.size())
                return true;
            else if (xy == -1) {
                q.push(xy);
                ++level;
                continue;
            }
            
            if (visited.find(xy) != visited.end())
                continue;
                
            visited.insert(xy);
            
            if (x < s1.size() && s1[x] == s3[level])
                q.push(y << 32 | x+1);
                
            if (y < s2.size() && s2[y] == s3[level])
                q.push((y+1) << 32 | x);
        }
        
        return false;
    }
};

该算法参考自：

https://leetcode.com/discuss/19973/8ms-c-solution-using-bfs-with-explanation