攀爬字符串

给定一个字符串 S1，将其递归地分割成两个非空子字符串,从而将其表示为二叉树。

下面是s1 = "great"的一个可能表达：

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

在攀爬字符串的过程中，我们可以选择其中任意一个非叶节点，然后交换该节点的两个儿子。

例如，我们选择了 "gr" 节点，并将该节点的两个儿子进行交换，从而产生了攀爬字符串 "rgeat"。

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

我们认为， "rgeat" 是 "great" 的一个攀爬字符串.

类似地，如果我们继续将其节点 "eat" 和 "at" 进行交换，就会产生新的攀爬字符串 "rgtae"。

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

同样地，"rgtae" 也是 "great"的一个攀爬字符串。

给定两个相同长度的字符串s1 和 s2，判定 s2 是否为 s1 的攀爬字符串。

class Solution {
public:
    /**
     * @param s1 A string
     * @param s2 Another string
     * @return whether s2 is a scrambled string of s1
     */
    bool isScramble(string& s1, string& s2) {
        // Write your code here
        int n = s1.size();
        if (s1.size() != s2.size())
        {
            return false;
        }
        
        vector<vector<vector<bool > > > buf(n,vector<vector<bool> >(n,vector<bool>(n+1,false)));
        for (int k = 1; k <= n; k++)
        {
            for (int i = 0; i <= n-k; i++)
            {
                for (int j = 0; j <= n-k; j++)
                {
                    if (k == 1)
                    {
                        buf[i][j][1] = (s1[i]==s2[j]);
                    }
                    else
                    {
                        for (int index = 1; index < k; index++)
                        {
                            if ((buf[i][j][index] && buf[i+index][j+index][k-index])
                                 || (buf[i][j+k-index][index] && buf[i+index][j][k-index]))
                            {
                                buf[i][j][k] = true;
                                break;
                            }
                        }
                    }
                }
            }
        }
        return buf[0][0][n];
    }
};