leetcode[87]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.

class Solution {
public:
bool isScramble(string s1, string s2) {
        if(s1==s2)return true;
        if(s1.length()!=s2.length())return false;
        int length=s1.size();
        int a[26]={0};
        for(int i=0;i< length;i++)
        {
            a[s1[i]-'a']++;
            a[s2[i]-'a']--;
        }
        for(int i=0;i<26;i++)
        {
            if(a[i]!=0)return false;
        }
        bool f[length][length][length];  
        memset(f, false, sizeof(bool) * length * length * length);  
//        vector<vector<vector<bool>>> f( length,vector<vector<bool>> ( length,vector<bool> ( length, false)));
        for (int k=1;k<= length;k++)
        {
            for (int i=0;i<= length-k;i++)
            {
                for (int j=0;j<= length-k;j++)
                {
                    if (k==1)
                    {
                        f[i][j][k]=(s1[i]==s2[j]);
                    } 
                    else
                    {
                        for (int kk=1;kk<k;kk++)
                        {
                            if ((f[i][j][kk]&&f[i+kk][j+kk][k-kk])||(f[i+kk][j][k-kk]&&f[i][j+k-kk][kk]))
                            {
                                f[i][j][k]=true;
                                break;
                            }
                        }
                    }
                }
            }
        }
        return f[0][0][length];
    }
/*
bool isScramble(string s1, string s2) {  
        // Start typing your C/C++ solution below  
        // DO NOT write int main() function  
        if (s1.length() != s2.length()) {  
            return false;  
        }  
        int length = s1.length();  
        bool f[length][length][length];  
        memset(f, false, sizeof(bool) * length * length * length);  
          
        for (int k = 1; k <= length; k++) {  
            for (int i = 0; i <= length - k; i++) {  
                for (int j = 0; j <= length - k; j++) {  
                    if (k == 1) {  
                        f[i][j][k] = s1[i] == s2[j];  
                    }  
                    else {  
                        for (int l = 1; l < k; l++) {  
                            if ((f[i][j][l] && f[i + l][j + l][k - l]) || (f[i][j + k - l][l] && f[i + l][j][k - l])) {  
                                f[i][j][k] = true;  
                                break;  
                            }                              
                        }  
                    }  
                }  
            }              
        }  
                  
        return f[0][0][length];  
    } 
bool isScramble(string s1, string s2) 
{
    if(s1==s2)return true;
    if(s1.length()!=s2.length())return false;
    int len1=s1.size(), len2=s2.size();
    int a[26]={0};
    for(int i=0;i<len1;i++)
    {
        a[s1[i]-'a']++;
        a[s2[i]-'a']--;
    }
    for(int i=0;i<26;i++)
    {
        if(a[i]!=0)return false;
    }
    for(int i=1;i<len1;i++)
    {
        bool res1=isScramble(s1.substr(0,i),s2.substr(0,i))&&isScramble(s1.substr(i),s2.substr(i));
        bool res2=isScramble(s1.substr(0,i),s2.substr(len2-i,i))&&isScramble(s1.substr(i),s2.substr(0,len2-i));
        bool res=res1||res2;
        if(res) return res;
    }
    return false;
}
*/
};