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 ifs2 is a scrambled string of s1.

一开始用递归法作，结果超时。用动态规划法通过。

递归法：

class Solution {
public:
    bool isScramble(string s1, string s2) {
        int l = s1.length();
        int i = 0;
        
        if (s1 == s2) return true;

        if (l == 1) {
            if (s1[0] == s2[0]) 
                return true;
            else 
                return false;
        }

        if (l == 2) {
            if ((s1[0] == s2[0] && s1[1] == s2[1]) || (s1[0] == s2[1] && s1[1] == s2[0])) 
                return true;
            else
                return false;
        }

        string s11, s12, s21, s22;
        for (i = 1; i <= l-1; ++i) {
            s11 = s1.substr(0, i);
            s12 = s1.substr(i);
            s21 = s2.substr(0, i);
            s22 = s2.substr(i);

            if (isScramble(s11, s21) && isScramble(s12, s22)) 
                return true;            
                
            s21 = s2.substr(l-i);
            s22 = s2.substr(0, l-i);

            if (isScramble(s11, s21) && isScramble(s12, s22)) 
                return true;            
        }

        return false;
    }
};

动态规划：

class Solution {
public:
    #define T(x, y, z) t[(x)*l*l + (y)*l + (z)]
    bool isScramble(string s1, string s2) {
        const int l = s1.length();

        int *t = new int[l*l*l]();

        int i = 0, j = 0, k = 0, n = 0, r = 0;
        for (i = 0; i < l; ++i) {
            for (j = 0; j < l; ++j) {
                T(0, i, j) = s1[i] == s2[j] ? 1 : 0;
            }
        }

        for (k = 2; k <= l; ++k) {
            for (i = 0; i < l-k+1; ++i) {
                for (j = 0; j < l-k+1; ++j) {
                    r = 0;
                    for (n = 1; n < k; ++n) {
                        if ((T(k-n-1, i, j) && T(n-1, i+k-n, j+k-n)) || (T(k-n-1, i, j+n) && T(n-1, i+k-n, j))) {
                            r = 1;
                            break;
                        }
                    }
                    T(k-1, i, j) = r;
                }
            }
        }

        bool ret = T(l-1, 0, 0) == 1 ? true : false;
        delete[] t;

        return ret;
    }
};