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;

}

*/

};