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

 

分析：
這個問題是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         string st1 = s1, st2 = s2;
 9         sort(st1.begin(), st1.end());
10         sort(st2.begin(), st2.end());
11         for (int i = 0; i < l1; ++i) {
12             if (st1[i] != st2[i]) {
13                 return false;
14             }
15         }
16         string s11, s12, s21, s22;
17         bool res = false;
18         for (int i = 1; i < l1 && !res; ++i) {
19             s11 = s1.substr(0, i);
20             s12 = s1.substr(i, l1 - i);
21             s21 = s2.substr(0, i);
22             s22 = s2.substr(i, l1 - i);
23             res = isScramble(s11, s21) && isScramble(s12, s22);
24             if (!res) {
25                 s21 = s2.substr(0, l1 - i);
26                 s22 = s2.substr(l1 - i, i);
27                 res = isScramble(s11, s22) && isScramble(s12, s21);
28             }
29         }
30         return res;
31     }
32 };

 

解法二（動態規劃）：
減小重複計算的方法就是動態規劃。動態規劃是一種神奇的算法技術，不親自去寫，是很難徹底掌握動態規劃的。

這裏我使用了一個三維數組boolean result[len][len][len],其中第一維爲子串的長度，第二維爲s1的起始索引，第三維爲s2的起始索引。
result[k][i][j]表示s1[i...i+k]是否能夠由s2[j...j+k]變化得來。

 1 public class Solution {
 2     public boolean isScramble(String s1, String s2) {
 3         int len = s1.length();
 4         if(len!=s2.length()){
 5             return false;
 6         }
 7         if(len==0){
 8             return true;
 9         }
10         
11         char[] c1 = s1.toCharArray();
12         char[] c2 = s2.toCharArray();
13         
14         boolean[][][] result = new boolean[len][len][len];
15         for(int i=0;i<len;++i){
16             for(int j=0;j<len;++j){
17                 result[0][i][j] = (c1[i]==c2[j]);
18             }
19         }
20         
21         for(int k=2;k<=len;++k){
22             for(int i=len-k;i>=0;--i){
23               for(int j=len-k;j>=0;--j){
24                   boolean r = false;
25                   for(int m=1;m<k && !r;++m){
26                       r = (result[m-1][i][j] && result[k-m-1][i+m][j+m]) || (result[m-1][i][j+k-m] && result[k-m-1][i+m][j]);
27                   }
28                   result[k-1][i][j] = r;
29               }
30             }
31         }
32         
33         return result[len-1][0][0];
34     }
35 }