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.

Analsysi:

We observe that if s1[0..i] and s2[0...i] are scramble strings, then there must have a k (0<=k<i) so that

1. s1[0..k] and s2[0...k] are scarable && s1[k+1...i] and s2[k+1...i] are scramble.

2. OR s1[0...k] and s2[i-k...i] are scramble && s1[k...i] and s2[0...i+k] are scramble.

We then define the define the state d[k][i][j] as whether the string s1[i...i+k] and s2[j...j+k] are scramble. We then have the formula:

d[k][i][j] = true; if for any l that 1<=l<=k-1, we have:  1. d[l][i][j] && d[k-l][i+l][j+l]  ||  2. d[l][i][j+k-l] && d[k-l][i+l][j].

Otherweise d[k][i][j] = false;

Solution:

public class Solution {
    public boolean isScramble(String s1, String s2) {
        if (s1.length()!=s2.length()) return false;
        int len = s1.length();
        if (len==0) return true;

        boolean[][][] d = new boolean[len+1][len][len];
        for (int i=0;i<len;i++)
            for (int j=0;j<len;j++)
                if (s1.charAt(i)==s2.charAt(j))
                    d[1][i][j]=true;
                else d[1][i][j]=false;

        for (int k=2;k<=len;k++)
            for (int i=0;i<=len-k;i++)
                for (int j=0;j<=len-k;j++)
                    for (int l=1;l<=(k-1);l++){
                        d[k][i][j]=false;
                        if (d[l][i][j] && d[k-l][i+l][j+l]){
                            d[k][i][j]=true;
                            break;
                        } else if (d[l][i][j+k-l] && d[k-l][i+l][j]){
                            d[k][i][j]=true;
                            break;
                        }
                    }

         return d[len][0][0];
    }
}