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.分析：
这个问题是google的面试题。由于一个字符串有很多种二叉表示法，貌似很难判断两个字符串是否可以做这样的变换。
对付复杂问题的方法是从简单的特例来思考，从而找出规律。
先考察简单情况：
字符串长度为1：很明显，两个字符串必须完全相同才可以。
字符串长度为2：当s1="ab", s2只有"ab"或者"ba"才可以。
对于任意长度的字符串，我们可以把字符串s1分为a1,b1两个部分，s2分为a2,b2两个部分，满足（(a1~a2) && (b1~b2)）或者 （(a1~b2) && (a1~b2)）
如此，我们找到了解决问题的思路。首先我们尝试用递归来写。
解法一（递归）:
两个字符串的相似的必备条件是含有相同的字符集。简单的做法是把两个字符串的字符排序后，然后比较是否相同。
加上这个检查就可以大大的减少递归次数。
代码如下：
1 class Solution { 2 public: 3 bool isScramble(string s1, string s2) { 4 int l1=s1.length(); 5 int l2=s2.length(); 6 if(l1!=l2) return false; 7 if(l1==1) return s1==s2; 8 int A[26]={0}; 9 for(int i=0;i<l1;i++) 10 ++A[s1[i]-'a']; 11 for(int i=0;i<l2;i++) 12 --A[s2[i]-'a']; 13 for(int i=0;i<26;i++) 14 if(A[i]!=0) return false; 15 bool res=false; 16 for(int i=1;i<l1&&!res;i++){ 17 res=isScramble(s1.substr(0,i),s2.substr(0,i))&&isScramble(s1.substr(i),s2.substr(i)); 18 if(!res) 19 res=isScramble(s1.substr(0,i),s2.substr(l1-i))&&isScramble(s1.substr(i),s2.substr(0,l1-i)); 20 } 21 return res; 22 } 23 };
解法二（动态规划）：
当然，这道题也可以用动态规划Dynamic Programming，根据以往的经验来说，根字符串有关的题十有八九可以用DP来做，那么难点就在于如何找出递推公式。参见网友Code Ganker的博客，这其实是一道三维动态规划的题目，我们提出维护量res[i][j][n]，其中i是s1的起始字符，j是s2的起始字符，而n是当前的字符串长度，res[i][j][len]表示的是以i和j分别为s1和s2起点的长度为len的字符串是不是互为scramble。
有了维护量我们接下来看看递推式，也就是怎么根据历史信息来得到res[i][j][len]。判断这个是不是满足，其实我们首先是把当前s1[i...i+len-1]字符串劈一刀分成两部分，然后分两种情况：第一种是左边和s2[j...j+len-1]左边部分是不是scramble，以及右边和s2[j...j+len-1]右边部分是不是scramble；第二种情况是左边和s2[j...j+len-1]右边部分是不是scramble，以及右边和s2[j...j+len-1]左边部分是不是scramble。如果以上两种情况有一种成立，说明s1[i...i+len-1]和s2[j...j+len-1]是scramble的。而对于判断这些左右部分是不是scramble我们是有历史信息的，因为长度小于n的所有情况我们都在前面求解过了（也就是长度是最外层循环）。
上面说的是劈一刀的情况，对于s1[i...i+len-1]我们有len-1种劈法，在这些劈法中只要有一种成立，那么两个串就是scramble的。
总结起来递推式是res[i][j][len] = || (res[i][j][k]&&res[i+k][j+k][len-k] || res[i][j+len-k][k]&&res[i+k][j][len-k]) 对于所有1<=k<len，也就是对于所有len-1种劈法的结果求或运算。因为信息都是计算过的，对于每种劈法只需要常量操作即可完成，因此求解递推式是需要O(len)（因为len-1种劈法）。
如此总时间复杂度因为是三维动态规划，需要三层循环，加上每一步需要线行时间求解递推式，所以是O(n^4)。虽然已经比较高了，但是至少不是指数量级的，动态规划还是有很大优势的，空间复杂度是O(n^3)。代码如下：
1 // DP 2 class Solution { 3 public: 4 bool isScramble(string s1, string s2) { 5 if (s1.size() != s2.size()) return false; 6 if (s1 == s2) return true; 7 int n = s1.size(); 8 vector<vector<vector<bool> > > dp (n, vector<vector<bool> >(n, vector<bool>(n + 1, false))); 9 for (int i = 0; i < n; ++i) { 10 for (int j = 0; j < n; ++j) { 11 dp[i][j][1] = s1[i] == s2[j]; 12 } 13 } 14 for (int len = 2; len <= n; ++len) { 15 for (int i = 0; i <= n - len; ++i) { 16 for (int j = 0; j <= n - len; ++j) { 17 for (int k = 1; k < len; ++k) { 18 if ((dp[i][j][k] && dp[i + k][j + k][len - k]) || (dp[i + k][j][len - k] && dp[i][j + len - k][k])) { 19 dp[i][j][len] = true; 20 } 21 } 22 } 23 } 24 } 25 return dp[0][0][n]; 26 } 27 };