題目：
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.
題解：
這道題完全轉載code ganker（http://blog.csdn.net/linhuanmars/article/details/24506703）：
“這道題看起來是比較復雜的，如果用brute force，每次做切割，然后遞歸求解，是一個非多項式的復雜度，一般來說這不是面試官想要的答案。
這其實是一道三維動態規划的題目，我們提出維護量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)。代碼如下：”
代碼如下：
2 if(s1== null || s2== null || s1.length()!=s2.length())
3 return false;
4 if(s1.length()==0)
5 return true;
6 boolean[][][] res = new boolean[s1.length()][s2.length()][s1.length()+1];
7 for( int i=0;i<s1.length();i++)
8 {
9 for( int j=0;j<s2.length();j++)
10 {
11 res[i][j][1] = s1.charAt(i)==s2.charAt(j);
12 }
13 }
14 for( int len=2;len<=s1.length();len++)
15 {
16 for( int i=0;i<s1.length()-len+1;i++)
17 {
18 for( int j=0;j<s2.length()-len+1;j++)
19 {
20 for( int k=1;k<len;k++)
21 {
22 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];
23 }
24 }
25 }
26 }
27 return res[0][0][s1.length()];
28 }
同樣這道題也可以用遞歸來做。
我個人覺得用遞歸做更加方便簡單些，思路還是上面那個思路，分兩刀那種（底下解釋引用自：http://blog.unieagle.net/2012/10/23/leetcode%E9%A2%98%E7%9B%AE%EF%BC%9Ascramble-string%EF%BC%8C%E4%B8%89%E7%BB%B4%E5%8A%A8%E6%80%81%E8%A7%84%E5%88%92/）：
“簡單的說，就是s1和s2是scramble的話，那么必然存在一個在s1上的長度l1，將s1分成s11和s12兩段，同樣有s21和s22。
那么要么s11和s21是scramble的並且s12和s22是scramble的；要么s11和s22是scramble的並且s12和s21是scramble的。”
代碼：
2 if(s1.length() != s2.length())
3 return false;
4
5 if(s1.length()==1 && s2.length()==1)
6 return s1.charAt(0) == s2.charAt(0);
7
8 char[] t1 = s1.toCharArray(), t2 = s2.toCharArray();
9 Arrays.sort(t1);
10 Arrays.sort(t2);
11 if(! new String(t1).equals( new String(t2)))
12 return false;
13
14 if(s1.equals(s2))
15 return true;
16
17 for( int split = 1; split < s1.length(); split++){
18 String s11 = s1.substring(0, split);
19 String s12 = s1.substring(split);
20
21 String s21 = s2.substring(0, split);
22 String s22 = s2.substring(split);
23 if(isScramble(s11, s21) && isScramble(s12, s22))
24 return true;
25
26 s21 = s2.substring(0, s2.length() - split);
27 s22 = s2.substring(s2.length() - split);
28 if(isScramble(s11, s22) && isScramble(s12, s21))
29 return true;
30 }
31 return false;
32 }
Reference：
http://www.cnblogs.com/lichen782/p/leetcode_Scramble_String.html
http://blog.unieagle.net/2012/10/23/leetcode%E9%A2%98%E7%9B%AE%EF%BC%9Ascramble-string%EF%BC%8C%E4%B8%89%E7%BB%B4%E5%8A%A8%E6%80%81%E8%A7%84%E5%88%92/
http://blog.csdn.net/fightforyourdream/article/details/17707187
http://blog.csdn.net/linhuanmars/article/details/24506703