LeetCode-Scramble String

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:

Code:

<span style="font-size:14px;">class Solution {
public:
    bool isScramble(string s1, string s2) {
        int length = s1.size();
        bool ***dp = new bool **[length];
        for (int i = 0; i < length; i++) {
            dp[i] = new bool *[length];
            for (int j = 0; j < length; j++) {
                dp[i][j] = new bool[length];
                memset(dp[i][j], false, sizeof(bool)*length);
            }
        }
        for (int i = length-1; i >= 0; i--)
            for (int j = length-1; j >= 0; j--)
                for (int k = 1; k <= length-max(i, j); k++) {
                    if (s1.substr(i, k) == s2.substr(j, k))
                        dp[i][j][k-1] = true;
                    else {
                        for (int l = 1; l <= k; l++) {
                            if ((dp[i][j][l-1] && dp[i+l][j+l][k-l-1]) ||
                                (dp[i][j+k-l][l-1] && dp[i+l][j][k-l-1])) {
                                    dp[i][j][k-1] = true;
                                    break;
                            }
                        }
                    }
                }
        bool result = dp[0][0][length-1];
        for (int i = 0; i < length; i++) {
            for (int j = 0; j < length; j++) {
                delete [] dp[i][j];
            }
            delete [] dp[i];
        }
        delete [] dp;
        return result;
    }
};</span>