[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.

 

可以用递归来解决，用备忘录方法加速。备忘录也就是DP的一种变形了，所以我就直接改为递推式的DP了。O(n^4)

class Solution {
private:
    bool f[100][100][100];
public:
    bool isScramble(string s1, string s2) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        if (s1.size() != s2.size())
            return false;
            
        for(int i = 0; i < s1.size(); i++)
            for(int j = 0; j < s2.size(); j++)
                f[1][i][j] = (s1[i] == s2[j]);
                
        for(int len = 2; len <= s1.size(); len++)
        {
            for(int s1Beg = 0; s1Beg < s1.size(); s1Beg++)
            {
                int s1End = s1Beg + len - 1;
                if (s1End >= s1.size())
                    break;
                
                for(int s2Beg = 0; s2Beg < s2.size(); s2Beg++)
                {
                    int s2End = s2Beg + len - 1;
                    if (s2End >= s2.size())
                        break;
                    
                    f[len][s1Beg][s2Beg] = false;    
                    for(int s1Mid = s1Beg; s1Mid < s1End; s1Mid++)
                    {
                        int leftSize = s1Mid - s1Beg + 1;
                        int rightSize = len - leftSize;
                        int s2Mid = s2Beg + leftSize - 1;
                        bool res1 = f[leftSize][s1Beg][s2Beg] && f[rightSize][s1Mid+1][s2Mid+1];
                        
                        s2Mid = s2End - leftSize;
                        bool res2 = f[leftSize][s1Beg][s2Mid+1] && f[rightSize][s1Mid+1][s2Beg];
                        
                        f[len][s1Beg][s2Beg] = f[len][s1Beg][s2Beg] || res1 || res2;
                    }
                }
            }
        }
        
        return f[s1.size()][0][0];
    }
};