首页 > 代码库 > Scramble String leetcode java

Scramble String leetcode java

题目

 

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