Scramble String-CSDN博客

本文链接：https://blog.csdn.net/yeshiwu/article/details/51767977

题目描述：

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.

这个题第一想法肯定是递归了，对于任意长度的字符串，我们可以把字符串s1分为a1,b1两个部分，s2分为a2,b2两个部分，满足（(a1~a2) && (b1~b2)）或者（(a1~b2) && (a1~b2)）
代码如下:

public class Solution {
     public boolean isScramble(String s1, String s2) {
        int n = s1.length();
        if(n != s2.length()) return false;
        if(n == 0) return true;
        
        int[] saved = new int[26];
        char[] ch1 = s1.toCharArray();
        char[] ch2 = s2.toCharArray();
        if(n == 1) return ch1[0] == ch2[0];
        for(char c:ch1)
            saved[c-'a'] += 1;
        for(char c:ch2)
            saved[c-'a'] -= 1;
        for(int i=0;i<26;i++)
            if(saved[i] != 0) return false;
        boolean res = false;
        for(int i=1;i<n && !res;i++){
            res = ( isScramble(s1.substring(0,i),s2.substring(0,i))
                && isScramble(s1.substring(i,n),s2.substring(i,n))
                ) ||
                (isScramble(s1.substring(0,i),s2.substring(n-i,n))
                && isScramble(s1.substring(i,n),s2.substring(0,n-i))
                );
        }
        return res;
    }
}

三位动态规划方法： booleanresult[len][len][len],其中第一维为子串的长度，第二维为s1的起始索引，第三维为s2的起始索引。
result[k][i][j]表示s1[i...i+k]是否可以由s2[j...j+k]变化得来。

public class Solution {
     public boolean isScramble(String s1, String s2) {
	    if(s1== null||s2==null||s1.length()!=s2.length())
	        return  false;
	    if(s1.length()==0)
	        return  true;
	    boolean[][][] res = new  boolean[s1.length()][s2.length()][s1.length()+1];
	    for(int i=0;i<s1.length();i++){
	        for(int j=0;j<s2.length();j++){
	            res[i][j][1] = s1.charAt(i)==s2.charAt(j);
	        }
	    }
	    for(int len=2;len<=s1.length();len++){
	        for(int i=0;i<s1.length()-len+1;i++){
	            for(int j=0;j<s2.length()-len+1;j++){              
	                for(int k=1;k<len;k++){
	                    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];
	                }
	            }
	        }
	    }
	    return res[0][0][s1.length()];
	}
}