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.

开始的思路是类似于二叉树的做法，发现不好找左右子的划分，各种WA，感觉是动态规划，但是我对动态规划不熟悉，没找出状态方程。搜了搜网上的解法，整理了一下：

设f[n][i][j]表示s1中从i位置开始长度为n的串是否与s2中从j位置开始长度为n的串互为scramble string，则有状态方程如下：

f[n][i][j] = f[n][i][j] || (f[k][i][j] && f[n-k][i+k][j+k]) || (f[k][i][j+n-k] && f[n-k][i+k][j])      k从1到n-1

由上述方程可以看出，计算f[n][i][j]时，n之前的已经计算过，i和j之后的已经计算过，因此，递归时候n++,i--,j--。

代码如下：

public boolean isScramble(String s1, String s2) {
        int N = s1.length();
        if(s1.length()!=s2.length()){
            return false;
        }
        boolean grid[][][] = new boolean[N+1][N][N];
        for(int i=0;i<N;i++){
            for(int j=0;j<N;j++){
                grid[1][i][j] = s1.charAt(i)==s2.charAt(j);
            }
        }
        for(int n=1;n<=N;n++){
            for(int i=N-n;i>=0;i--){
                for(int j=N-n;j>=0;j--){
                    for(int k=1;k<n;k++){
                        grid[n][i][j] = (grid[k][i][j] && grid[n-k][i+k][j+k]) || (grid[k][i][j+n-k] && grid[n-k][i+k][j]);
                        if(grid[n][i][j]==true){
                            break;
                        }
                    }
                }
            }
        }
        return grid[N][0][0];
    }

复杂度不会算了，从代码的循环上来看是O(n^4)，空间复杂度是O(n^3)

感觉还可以改一改，有一个思路，没有具体实现，不知道是否可行

每次在串s1中取子串0到i(i从1到n)，与s2中子串的前i个或后i个比较，若字符相同，递归判断是否是scramble string，比较字符相同就先排序，然后比较，排序为O(nlgn)，比较为O(n)，因此整体为O(nlgn)，每次从1到n，因此，为O(n^2*lgn)，每次最少可以将s1长度减1，因此，最多递归n次，因此，整体复杂度为O(n^3*lgn)。不知道这么算是否正确，以及复杂度的分析是否正确。