Scramble String leetcode java

愛做飯的小瑩子發表於2014-08-07
LeetCodeJava

題目：

 

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)。程式碼如下：”

 

程式碼如下：

 1 public boolean isScramble(String s1, String s2) {
 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的。”

 

程式碼：

 1 public boolean isScramble(String s1, String s2) {
 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

 

相關文章