Scramble String

-----QUESTION-----

Given a string s1, we may represent it as a binary tree by partitioning it to two non-empty substrings recursively.

Below is one possible representation of s1 = "great":

 great / \ gr eat / \ / \ g r e at / \ a t

To scramble the string, we may choose any non-leaf node and swap its two children.

For example, if we choose the node "gr" and swap its two children, it produces a scrambled string "rgeat".

 rgeat / \ rg eat / \ / \ r g e at / \ a t

We say that "rgeat" is a scrambled string of "great".

Similarly, if we continue to swap the children of nodes "eat" and "at", it produces a scrambled string "rgtae".

 rgtae / \ rg tae / \ / \ r g ta e / \ t a

We say that "rgtae" is a scrambled string of "great".

Given two strings s1 and s2 of the same length, determine if s2 is a scrambled string of s1.

-----SOLUTION-----

class Solution {
public:
    bool isScramble(string s1, string s2) {
        int len = s1.length();
        if(len==0) return true;
        if(s1 == s2) return true;
        vector<vector<vector<bool>>> dp(len, vector<vector<bool>>(len, vector<bool>(len+1, false) ) );
        for (int i = 0; i < len; ++i)
        {
            for (int j = 0; j < len; ++j)
            {
                dp[i][j][1] = s1[i]==s2[j];
            }
        }
        
        for(int levelSize = 2; levelSize <= len; levelSize++)
        {
            for(int s1Pointer = 0; s1Pointer+levelSize-1 < len; s1Pointer++)
            {
                for(int s2Pointer = 0; s2Pointer+levelSize-1 < len; s2Pointer++)
                {
                    for(int split = 1; split < levelSize; split++)
                    {
                        if ((dp[s1Pointer][s2Pointer][split] && dp[s1Pointer+split][s2Pointer+split][levelSize-split]) ||
                        (dp[s1Pointer][s2Pointer+levelSize-split][split] && dp[s1Pointer+split][s2Pointer][levelSize-split]))
                        {
                            dp[s1Pointer][s2Pointer][levelSize] = true;
                            break;
                        };
                    }           
                }
            }
        }
        return dp[0][0][len]; 
    }
};

以下递归代码在Judge Large时Time limit exceeded

class Solution {
public:
    bool isScramble(string s1, string s2) {
        if(s1 == s2) return true;
        for(int isep = 1; isep < s1.size(); ++ isep) {
            //seporate s1 as [0,isep - 1],[isep, s1.size() - 1]
            string seg11 = s1.substr(0,isep);
            string seg12 = s1.substr(isep);
            {//see if forward order is ok
                string seg21 = s2.substr(0,isep);
                string seg22 = s2.substr(isep);
                if(isScramble(seg11,seg21) && isScramble(seg12,seg22)) return true;
            }
            {//see if reverse order is ok
                string seg21 = s2.substr(s2.size() - isep);
                string seg22 = s2.substr(0,s2.size() - isep);
                if(isScramble(seg11,seg21) && isScramble(seg12,seg22)) return true;
            }
        }
        return false;
    }
};