【leetcode】String——Scramble String（87）

题目：

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.

思路1：dp

用三维数组dp[i][j][k] 表示 ： s1从i开始  s2从j开始 长度为k的字符子串是Scramble。最终返回dp[0][0][len]。

在求dp[i][j][k]时，可以将k长的字串一分为二

          S1 [   x1    |         x2         ]
               i         i + q                i + k - 1
          
          here we have two possibilities:
               
          S2 [   y1    |         y2         ]
               j         j + q                j + k - 1
             
          or 
          
          S2 [       y1        |     y2     ]
               j                 j + k - q    j + k - 1

第一个情况：如果dp[i][j][q]和dp[i+q][j+q][k-q]均为true，即前后对应都是scramble，则dp[i][j][k]为true

第二个情况：如果dp[i][j+k-q][q]和dp[i+q][j][k-q]均为true，即前后交叉对应是scramble，则dp[i][j][k]为true

两种情况有一个为true即可

代码1：

public boolean isScramble(String s1, String s2) {
	if(s1.length()!=s2.length())
		return false;
	if(s1.equals(s2))
		return true;
	int len  = s1.length();
    boolean dp[][][] = new boolean [len][len][len+1];
	for(int k=1;k<=len;k++){
		for(int i=0;i+k<=len;i++){
			for(int j=0;j+k<=len;j++){
				if(k==1){
					if(s1.charAt(i)==s2.charAt(j))
						dp[i][j][k]=true;
					else
						dp[i][j][k]=false;
				}else{
					for(int x = 1;x<k&& !dp[i][j][k];x++){
						dp[i][j][k]=(dp[i][j][x]&&dp[i+x][j+x][k-x])||(dp[i][j+k-x][x]&&dp[i+x][j][k-x]);
					}
				}
			}
		}
	}
	return dp[0][0][len];
}

思路2：递归recursive

整体的思路和dp差不多，把字符串拆分2部分，前后比较，分两种情况。

代码2：

public boolean isScramble(String s1, String s2) {
    int len1 = s1.length(), len2 = s2.length();
    if (len1 != len2) return false;
    if (len1 == 0) return true;
    // pruning 
    if (s1.equals(s2)) return true;
    int[] count = new int[256];
    for (int i = 0; i < len1; i++){
        count[s1.charAt(i)]++;
        count[s2.charAt(i)]--;
    }
    for (int i = 0; i < len1; i++){
        if (count[s1.charAt(i)] != 0) return false;
    }
    for (int i = 1; i < len1; i++){
        if (isScramble(s1.substring(0, i), s2.substring(0, i)) && isScramble(s1.substring(i), s2.substring(i)))
            return true;
        if (isScramble(s1.substring(0, i), s2.substring(len1 - i)) && isScramble(s1.substring(i), s2.substring(0, len1 - i)))
            return true;
    }
    return false;
}