LeetCode - Interleaving String

Interleaving String

2014.2.26 02:48

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.

Solution1:

　　This problem can be solved with DFS, but the time is untolerable. Dynamic programming would be a better way out.

　　The word "interleaving" means every letter from s3 must come from either s1 or s2, so every letter in s3 will be compared with s1 and s2.

　　Let f[i][j] be the DP array. f[i][j] means whether s1[1:i] and s2[1:j] forms the interleaving string in s3[1:i+j]:

　　　　1. f[0][0]=true.

　　　　2. if s3[i+j]==s1[i] and f[i-1][j]==true, f[i][j]=true.

　　　　3. if s3[i+j]==s2[j] and f[i][j-1]==true, f[i][j]=true.

　　Total time and space complexities are both O(n^2).

Accepted code:

// 3CE, 1TLE, 2WA, 1AC, O(n^2) solution with DP, space can be optimized.
class Solution {
public:
    bool isInterleave(string s1, string s2, string s3) {
        int len1;
        int len2;
        int len3;
        
        len1 = (int)s1.length();
        len2 = (int)s2.length();
        len3 = (int)s3.length();
        if (len3 != len1 + len2) {
            return false;
        }
        
        if (len1 == 0) {
            return s2 == s3;
        } else if (len2 == 0) {
            return s1 == s3;
        }
        
        int i, j;
        dp.resize(len1 + 1);
        for (i = 0; i < len1 + 1; ++i) {
            dp[i].resize(len2 + 1);
        }
        
        dp[0][0] = 1;
        for (i = 1; i <= len1; ++i) {
            if (dp[i - 1][0] && s3[i - 1] == s1[i - 1]) {
                dp[i][0] = 1;
            }
        }
        for (j = 1; j <= len2; ++j) {
            if (dp[0][j - 1] && s3[j - 1] == s2[j - 1]) {
                dp[0][j] = 1;
            }
        }
        for (i = 1; i <= len1; ++i) {
            for (j = 1; j <= len2; ++j) {
                dp[i][j] = 0;
                dp[i][j] = dp[i][j] || (dp[i - 1][j] && (s3[i + j - 1] == s1[i - 1]));
                dp[i][j] = dp[i][j] || (dp[i][j - 1] && (s3[i + j - 1] == s2[j - 1]));
            }
        }
        int result = dp[len1][len2];
        
        for (i = 0; i < len1 + 1; ++i) {
            dp[i].clear();
        }
        dp.clear();
        
        return result == 1;
    }
private:
    vector<vector<int> > dp;
};

Solution2:

　　Space-optimized version, only O(n) space is needed.

Accepted code:

// 1AC, space optimized.
class Solution {
public:
    bool isInterleave(string s1, string s2, string s3) {
        int len1;
        int len2;
        int len3;
        
        len1 = (int)s1.length();
        len2 = (int)s2.length();
        len3 = (int)s3.length();
        if (len3 != len1 + len2) {
            return false;
        }
        
        if (len1 == 0) {
            return s2 == s3;
        } else if (len2 == 0) {
            return s1 == s3;
        }
        
        if (len1 < len2) {
            return isInterleave(s2, s1, s3);
        }
        
        int i, j;
        dp.resize(2);
        for (i = 0; i < 2; ++i) {
            dp[i].resize(len2 + 1);
        }
        
        dp[0][0] = 1;
        for (j = 1; j <= len2; ++j) {
            if (dp[0][j - 1] && s3[j - 1] == s2[j - 1]) {
                dp[0][j] = 1;
            } else {
                dp[0][j] = 0;
            }
        }
        
        int flag = 1, nflag = !flag;
        for (i = 1; i <= len1; ++i) {
            if (dp[nflag][0] && s3[i - 1] == s1[i - 1]) {
                dp[flag][0] = 1;
            } else {
                dp[flag][0] = 0;
            }
            for (j = 1; j <= len2; ++j) {
                dp[flag][j] = 0;
                dp[flag][j] = dp[flag][j] || (dp[nflag][j] && (s3[i + j - 1] == s1[i - 1]));
                dp[flag][j] = dp[flag][j] || (dp[flag][j - 1] && (s3[i + j - 1] == s2[j - 1]));
            }
            flag = !flag;
            nflag = !flag;
        }
        int result = dp[nflag][len2];
        
        for (i = 0; i < 2; ++i) {
            dp[i].clear();
        }
        dp.clear();
        
        return result == 1;
    }
private:
    vector<vector<int> > dp;
};