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.

思路： 用DP 来做 ，设置一个三维boolean array， dp[i][j][len] 为true  代表 ，s1 start from i, s2 start from j, they are length equals len scramble string . At first, they need to initialize the len = 1 . 然后用 len  作为外围循环， 来查找。  

如果俩字符串是 scramble 他们中间肯定有个地方能劈开， 也是 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])

易错点: Length could be n. And in the second time traverse, the i + len should be less or equal than n, same to j + len.

public class Solution {
    public boolean isScramble(String s1, String s2) {
        if(s1 == null)
            return true;
        int n = s1.length();
        boolean[][][] dp = new boolean[n][n][n + 1];
        //initialize
        for(int i = 0; i < n; i++){
            for(int j = 0; j < n; j++){
                if(s1.charAt(i) == s2.charAt(j)){
                    dp[i][j][1] = true;
                }
            }
        }
        
        for(int len = 2; len <= n; len++){//---length could be n
            for(int i = 0; i + len <= n; i++){//---Pay more attation at here
                for(int j = 0; j + len <= n; j++){//---
                    for(int k = 1; k < len; k++){
                        dp[i][j][len] |= (dp[i][j][k] && dp[i + k][j + k][len - k]) || (dp[i][j + k][len - k] && dp[i + len - k][j][k]);
                    }
                }
            }
        }
        return dp[0][0][n];
    }
}