LeetCode Interleaving String

记忆搜索总是一个快速的方法（这里假设测试用例中s1和s2的长度都不超过(2^16) - 1 ）， 当然用记忆搜索的，往往就可以写成DP的形式的，不用担心大数据时栈溢出了

#include <iostream>
#include <cstdlib>
#include <string>
#include <vector>
#include <unordered_map>

using namespace std;

class Solution {
private:
    unordered_map<unsigned int, bool> memo;
public:
    bool isInterleave(string s1, string s2, string s3) {
        memo.clear();
        return dfs(s1, 0, s2, 0, s3);
    }
    
    bool dfs(string& s1, int apos, string &s2, int bpos, string &s3) {
        unsigned int id = (apos << 16) | bpos;
        auto iter = memo.find(id);
        if (iter != memo.end()) return iter->second;
        
        int cpos = apos + bpos;
        if (apos == s1.length() && bpos == s2.length() && cpos == s3.length()) {
            memo.insert(make_pair(id, true));
            return true;
        }
        
        bool res = false;
        
        if (apos < s1.length() && s1[apos] == s3[cpos]) {
            if (dfs(s1, apos + 1, s2, bpos, s3)) {
                res = true;
            }
        }
        
        if (!res && bpos < s2.length() && s2[bpos] == s3[cpos]) {
            if (dfs(s1, apos, s2, bpos + 1, s3)) {
                res = true;
            }
        }
        
        memo.insert(make_pair(id, res));
        return res;
    }
};

int main() {

    Solution s;
    cout<<s.isInterleave("aabcc", "dbbca", "aadbbbaccc")<<endl;
    return 0;
}

简化dp，空间O(max(s1.len, s2.len))

class Solution {
public:
    bool isInterleave(string s1, string s2, string s3) {
        return dp(s1, s2, s3);
    }
    bool dp_helper(string &s1, string &s2, string &s3) {
        int rows = s1.length() + 1;
        int cols = s2.length() + 1;
        
        vector<bool> dp(cols, false);
        dp[0] = true;
        
        // init the dp array
        for (int i=1; i<cols; i++) {
            if (s3[i - 1] != s2[i - 1]) break;
            dp[i] = true;
        }
        
        // simplified dp using O( max(len(s1), len(s2)) ) space
        for (int i=1; i<rows; i++) {
            // whether all chars from s1 or not
            dp[0] = dp[0] && (s1[i-1] == s3[i-1]);
            for (int j=1; j<cols; j++) {
                int pos = i + j - 1;
                
                if (dp[j] && s1[i-1] == s3[pos]) {
                    // char from s1, if so, keep dp[j] unchanged( = true)
                } else if (dp[j-1] && s2[j-1] == s3[pos]) {
                    // char from s2
                    dp[j] = true;
                } else {
                    dp[j] = false;
                }
            }
        }
        return dp[cols - 1];
    }
    
    bool dp(string &s1, string &s2, string &s3) {
        int la = s1.length();
        int lb = s2.length();
        if (la + lb != s3.length()) return false;
        if (la < lb) {
            return dp_helper(s1, s2, s3);
        } else {
            return dp_helper(s2, s1, s3);
        }
    }
};

 懒得化简了

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