Scramble String

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.

Solution 

It seems that this problem is not easy to solve. However, if we use recursion to solve this problem, it is not difficult at all.

If string1 is a scrambled string of string2, we can break the two strings into two partition. string1 becomes string11 and string12 while string2 becomes string21 and string22.

If scramble(string11, string21) && scramble(string12, string22) is true, or scramble(string11, string22) && scramble(string21, string12) is true, then string1 is the scrambled string of string2.

For example, 

"great" and "rgeat" 

great -> "gr"  "eat"

rgeat -> "rg"   "eat"      (string11, string21) && (string12, string22) == true

For another example,

"rgtae" and "great" 

For the substring "tae" and "eat",

"tae" -> "ta" and "e"

"eat" -> "e" and "at"             (string11, string22) &&(string12, string21) == true

If we do not do any preprocessing for this problem, the time will be out, so we need to consider some cases:

1. If the length of two strings are not equal, false;

2. If two strings has different characters, false;

3. If two strings are totally the same, true.

public class Solution {
    public boolean isScramble(String s1, String s2) {
        if (s1.length() != s2.length())
            return false;
        
        if (s1.equals(s2))
            return true;
        
        int[] ch = new int[26];
        for (int i = 0; i < s1.length(); i++) {
            ch[s1.charAt(i) - 'a']++;
            ch[s2.charAt(i) - 'a']--;
        }
        
        for (int i = 0; i < 26; i++) {
            if (ch[i] != 0)
                return false;
        }
        
        for (int split = 1; split < s1.length(); split++) {
            String s11 = s1.substring(0, split);
            String s12 = s1.substring(split);
            
            String s21 = s2.substring(0, split);
            String s22 = s2.substring(split);
            
            if (isScramble(s11,s21) && isScramble(s12,s22)) return true;
            
            s21 = s2.substring(0, s1.length() - split);
            s22 = s2.substring(s1.length() - split);
            
            if (isScramble(s11,s22) && isScramble(s12,s21)) return true;
        }
        return false;
    }
}