Hard！html
題目描述：算法
給定一個字符串 s1，咱們能夠把它遞歸地分割成兩個非空子字符串，從而將其表示爲二叉樹。數組
下圖是字符串 s1 = "great" 的一種可能的表示形式。ide
great
/ \
gr eat
/ \ / \
g r e at
/ \
a t
在擾亂這個字符串的過程當中，咱們能夠挑選任何一個非葉節點，而後交換它的兩個子節點。post
例如，若是咱們挑選非葉節點 "gr" ，交換它的兩個子節點，將會產生擾亂字符串 "rgeat" 。spa
rgeat
/ \
rg eat
/ \ / \
r g e at
/ \
a t
咱們將 "rgeat」 稱做 "great" 的一個擾亂字符串。.net
一樣地，若是咱們繼續將其節點 "eat" 和 "at" 進行交換，將會產生另外一個新的擾亂字符串 "rgtae" 。code
rgtae
/ \
rg tae
/ \ / \
r g ta e
/ \
t a
咱們將 "rgtae」 稱做 "great" 的一個擾亂字符串。htm
給出兩個長度相等的字符串 s1 和 s2，判斷 s2 是不是 s1 的擾亂字符串。blog
示例 1:
輸入: s1 = "great", s2 = "rgeat" 輸出: true
示例 2:
輸入: s1 = "abcde", s2 = "caebd" 輸出: false
解題思路：
這道題定義了一種爬行字符串（擾亂字符串），就是說假如把一個字符串當作一個二叉樹的根，而後它的非空子字符串是它的子節點，而後交換某個子字符串的兩個子節點，從新爬行回去造成一個新的字符串，這個新字符串和原來的字符串互爲爬行字符串。
這道題能夠用遞歸Recursion或是動態規劃Dynamic Programming來作，咱們先來看遞歸的解法，參見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的。就拿題目中的例子 rgeat 和 great 來講，rgeat 可分紅 rg 和 eat 兩段， great 可分紅 gr 和 eat 兩段，rg 和 gr 是scrambled的， eat 和 eat 固然是scrambled。根據這點，咱們能夠寫出代碼以下。
C++解法一：
1 // Recursion 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 string str1 = s1, str2 = s2; 8 sort(str1.begin(), str1.end()); 9 sort(str2.begin(), str2.end()); 10 if (str1 != str2) return false; 11 for (int i = 1; i < s1.size(); ++i) { 12 string s11 = s1.substr(0, i); 13 string s12 = s1.substr(i); 14 string s21 = s2.substr(0, i); 15 string s22 = s2.substr(i); 16 if (isScramble(s11, s21) && isScramble(s12, s22)) return true; 17 s21 = s2.substr(s1.size() - i); 18 s22 = s2.substr(0, s1.size() - i); 19 if (isScramble(s11, s21) && isScramble(s12, s22)) return true; 20 } 21 return false; 22 } 23 };
這道題也能夠用動態規劃Dynamic Programming，根據以往的經驗來講，根字符串有關的題十有八九能夠用DP來作，那麼難點就在於如何找出遞推公式。參見https://blog.csdn.net/linhuanmars/article/details/24506703，這實際上是一道三維動態規劃的題目，咱們提出維護量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)。
C++解法二：
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 };
上面的代碼的實現過程以下，首先按單個字符比較，判斷它們之間是不是scrambled的。在更新第二個表中第一個值(gr和rg是否爲scrambled的)時，比較了第一個表中的兩種構成，一種是 g與r, r與g，另外一種是 g與g, r與r，其中後者是真，只要其中一個爲真，則將該值賦真。其實這個原理和以前遞歸的原理很像，在判斷某兩個字符串是否爲scrambled時，比較它們全部可能的拆分方法的子字符串是不是scrambled的，只要有一個種拆分方法爲真，則比較的兩個字符串必定是scrambled的。比較 rge 和 gre 的實現過程以下所示：
r g e
g x √ x
r √ x x
e x x √
rg ge
gr √ x
re x x
rge
gre √
DP的另外一種寫法，參考http://blog.sina.com.cn/s/blog_b9285de20101gy6n.html，思路都同樣。
C++解法三：
1 // Still 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 = n - 1; i >= 0; --i) { 10 for (int j = n - 1; j >= 0; --j) { 11 for (int k = 1; k <= n - max(i, j); ++k) { 12 if (s1.substr(i, k) == s2.substr(j, k)) { 13 dp[i][j][k] = true; 14 } else { 15 for (int t = 1; t < k; ++t) { 16 if ((dp[i][j][t] && dp[i + t][j + t][k - t]) || (dp[i][j + k - t][t] && dp[i + t][j][k - t])) { 17 dp[i][j][k] = true; 18 break; 19 } 20 } 21 } 22 } 23 } 24 } 25 return dp[0][0][n]; 26 } 27 };
下面這種解法和第一個解法思路相同，只不過沒有用排序算法，而是採用了相似於求異構詞的方法，用一個數組來保存每一個字母出現的次數，後面判斷Scramble字符串的方法和以前的沒有區別。
C++解法四：
1 class Solution { 2 public: 3 bool isScramble(string s1, string s2) { 4 if (s1 == s2) return true; 5 if (s1.size() != s2.size()) return false; 6 int n = s1.size(), m[26] = {0}; 7 for (int i = 0; i < n; ++i) { 8 ++m[s1[i] - 'a']; 9 --m[s2[i] - 'a']; 10 } 11 for (int i = 0; i < 26; ++i) { 12 if (m[i] != 0) return false; 13 } 14 for (int i = 1; i < n; ++i) { 15 if ((isScramble(s1.substr(0, i), s2.substr(0, i)) && isScramble(s1.substr(i), s2.substr(i))) || (isScramble(s1.substr(0, i), s2.substr(n - i)) && isScramble(s1.substr(i), s2.substr(0, n - i)))) { 16 return true; 17 } 18 } 19 return false; 20 } 21 };
下面這種解法其實是解法二的遞歸形式，咱們用了memo數組來減小了大量的運算，注意這裏的memo數組必定要有三種狀態，初始化爲-1，區域內爲scramble是1，不是scramble是0，這樣就避免了已經算過了某個區間，但因爲不是scramble，從而又進行一次計算，從而會TLE，思路參見http://www.cnblogs.com/bambu/
C++解法五：
1 class Solution { 2 public: 3 bool isScramble(string s1, string s2) { 4 if (s1 == s2) return true; 5 if (s1.size() != s2.size()) return false; 6 int n = s1.size(); 7 vector<vector<vector<int>>> memo(n, vector<vector<int>>(n, vector<int>(n + 1, -1))); 8 return helper(s1, s2, 0, 0, n, memo); 9 } 10 bool helper(string& s1, string& s2, int idx1, int idx2, int len, vector<vector<vector<int>>>& memo) { 11 if (len == 0) return true; 12 if (len == 1) memo[idx1][idx2][len] = s1[idx1] == s2[idx2]; 13 if (memo[idx1][idx2][len] != -1) return memo[idx1][idx2][len]; 14 for (int k = 1; k < len; ++k) { 15 if ((helper(s1, s2, idx1, idx2, k, memo) && helper(s1, s2, idx1 + k, idx2 + k, len - k, memo)) || (helper(s1, s2, idx1, idx2 + len - k, k, memo) && helper(s1, s2, idx1 + k, idx2, len - k, memo))) { 16 return memo[idx1][idx2][len] = 1; 17 } 18 } 19 return memo[idx1][idx2][len] = 0; 20 } 21 };