[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.

题意：判断s2是否是s1的爬行字符串。

思路：如果s1和s2是scramble，那么必然存在一个在s1上的长度len1,将s1分成s11和s12两段同样有，s21和s22，那么要么s11和s21是scramble的并且s12和s22是scramble的；要么s11和s22是scramble的并且s12和s21是scramble的。如： rgeat 和 great 来说，rgeat 可分成 rg 和 eat 两段， great 可分成 gr 和 eat 两段，rg 和 gr 是scrambled的， eat 和 eat 当然是scrambled。参考了Grandyang和Eason Liu的博客。

代码如下：

class Solution {
public:
    bool isScramble(string s1, string s2) 
    {
        if(s1.size() !=s2.size())   return false;
        if(s1==s2)  return true;

        string str1=s1,str2=s2;
        sort(str1.begin(),str1.end());
        sort(str2.begin(),str2.end());
        if(str1 !=str2) return false;

        for(int i=1;i<s1.size();++i)
        {
            string s11=s1.substr(0,i);
            string s12=s1.substr(i);
            string s21=s2.substr(0,i);
            string s22=s2.substr(i);

            if(isScramble(s11,s21)&&isScramble(s12,s22))    
                return true;
            else
            {
                s21=s2.substr(s1.size()-i);
                s22=s2.substr(0,s1.size()-i);
                if(isScramble(s11,s21)&&isScramble(s12,s22))    
                    return true;
            }

        }    
        return false;
    }
};

注：substr()函数的用法：str.substr(start,Length)从某一位置start开始，指定长度为length的子字符串，若，length为0或者为负数返回空串；若，没有指定该参数，则，从指定位置开始直到字符串的最后。

方法二：动态规划，参见Grandyang的博客，维护量res[i][j][n]，其中i是s1的起始字符，j是s2的起始字符，而n是当前的字符串长度，res[i][j][len]表示的是以i和j分别为s1和s2起点的长度为len的字符串是不是互为scramble。看看递推式，也就是怎么根据历史信息来得到res[i][j][len]:当前s1[i...i+len-1]字符串劈一刀分成两部分，然后分两种情况：第一种是左边和s2[j...j+len-1]左边部分是不是scramble，以及右边和s2[j...j+len-1]右边部分是不是scramble；第二种情况是左边和s2[j...j+len-1]右边部分是不是scramble，以及右边和s2[j...j+len-1]左边部分是不是scramble,如果以上两种情况有一种成立，说明s1[i...i+len-1]和s2[j...j+len-1]是scramble的.

代码如下：

class Solution {
public:
    bool isScramble(string s1, string s2) 
    { 
        if(s1.size() !=s2.size())   return false;
        if(s1==s2)  return true;

        int len=s1.size();
        vector<vector<vector<bool>>> dp(len,
                    vector<vector<bool>>(len,vector<bool>(len+1,false)));
        for(int i=0;i<len;++i)
        {
            for(int j=0;j<len;++j)
            {
                dp[i][j][1]=(s1[i]==s2[j]);
            }
        }

        for(int n=2;n<=len;++n)
        {
            for(int i=0;i<=len-n;++i)
            {
                for(int j=0;j<=len-n;++j)
                {
                    for(int k=1;k<n;++k)
                    {
                        if((dp[i][j][k]&&dp[i+k][j+k][n-k])||
                        (dp[i+k][j][n-k]&&dp[i][j+n-k][k]))
                        {
                            dp[i][j][n]=true;
                        }
                    }
                }
            }
        }

        return dp[0][0][len];
    }
};