LeetCode 97. Interleaving String 递归/DP

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

Example 1:

Input: s1 = “aabcc”, s2 = “dbbca”, s3 = “aadbbcbcac”
Output: true

Example 2:

Input: s1 = “aabcc”, s2 = “dbbca”, s3 = “aadbbbaccc”
Output: false

分析过程：
    首先看到这个题，暴力什么的就别想了。容易想到的是用动态规划，那么问题来了，如何通过动态规划一步步将问题规模减小？
    根据题意，s3中的每个字符要么来自s1，要么来自s2，知道这个我们就可以将问题规模减小了，s3从最右边开始看(这里从最左边开始也行)，最后一个字符要么来自s1(aabcc)，要么来自s2(dbbca)，示例1中s3(aadbbcbcac)最后的c显然来自s1(aabcc)，匹配一个字符后，该问题的解就变成了它的子问题的解，子问题的参数为 s1:aabc，s2:bddca，s3:aadbbcbca，这里需要注意如果s1,s2,s3的最后一个字符都相同的情况。这样一步步匹配下去，问题的规模就减小了。知道以上就能写出下面这个递归版：

bool isInterleave(string s1, string s2, string s3) {
	if(s3.size() != s1.size() + s2.size())
		return false;
	
    if(s1.size() == 0)
    	return s2 == s3;
    	
    if(s2.size() == 0)
    	return s1 == s3;
    
    char c1 = s1[s1.size()-1];
    char c2 = s2[s2.size()-1];
    char c3 = s3[s3.size()-1];
    
    // 注意如果两个都能匹配的情况
    if(c3 == c1 && c3 == c2)
    	return isInterleave(s1,s2.substr(0,s2.size()-1),s3.substr(0,s3.size()-1)) || 
			   isInterleave(s1.substr(0,s1.size()-1),s2,s3.substr(0,s3.size()-1)) ;
    if(c3 == c2)
    	return isInterleave(s1,s2.substr(0,s2.size()-1),s3.substr(0,s3.size()-1));
    
    if(c3 == c1)
    	return isInterleave(s1.substr(0,s1.size()-1),s2,s3.substr(0,s3.size()-1));
    
    return false;
}

        但是这样写估计是AC不了的（我没有提交过，有哪位勇士愿意试试也无妨）。
        如何优化？这里是每一步都有字符串剪切并且还递归，相当耗时。

• 关于字符串剪切：首先想到的就是将参数中的字符串换为字符串引用，并且加上一个位置标志，标识当前想要匹配的子字符串的长度。这样每次传入函数的都是整个字符串的引用，子字符串的长度。
• 关于递归：使用记忆数组避免相同子问题得重复求解。如何在记忆数组中唯一标识一个子问题，使用三维数组？本题不用。因为本题中如果s1，s2的子串长度已经确定，如果s3的子串的长度不满足s3.len == s1.len + s2.len那可直接返回false，满足条件时再查看记忆数组。这样记忆数组就可以只有二维，即dp[L1][L2]表示子问题s1.substr(0,L1)，s2.substr(0,L2)，s3.substr(0,L1+L2)的结果。

代码：

Runtime: 4 ms, faster than 98.85%

class Solution {
public:
    vector<vector<int>> dp;
    
    bool helper(string &s1,int L1,string& s2,int L2,string& s3,int L3){
        if(L3 != L1 + L2)
            return 0;

        if(L1 == 0)
            return s2.substr(0,L2) == s3.substr(0,L3);

        if(L2 == 0)
            return s1.substr(0,L1) == s3.substr(0,L3);

        if(dp[L1][L2] != -1)
            return dp[L1][L2];

        char c1 = s1[L1-1];
        char c2 = s2[L2-1];
        char c3 = s3[L3-1];

        if(c3 == c1 && c3 == c2){
            dp[L1][L2-1] = helper(s1,L1,s2,L2-1,s3,L3-1);
            dp[L1-1][L2] = helper(s1,L1-1,s2,L2,s3,L3-1);
            return dp[L1][L2-1] || dp[L1-1][L2];
        }
        if(c3 == c2){
            return dp[L1][L2-1] = helper(s1,L1,s2,L2-1,s3,L3-1);
        }
        if(c3 == c1)
            return dp[L1-1][L2] = helper(s1,L1-1,s2,L2,s3,L3-1);

        return dp[L1][L2] =	0;
    }
    
    bool isInterleave(string s1, string s2, string s3) {
        int n1 = s1.size(),n2 = s2.size(),n3 = s3.size();
        vector<vector<int>> dp1(n1+1,vector<int>(n2+1,-1));
        dp = dp1;
        return helper(s1,s1.size(),s2,s2.size(),s3,s3.size());
    }
};

代码写得不是很优雅，还请各位赐教。