87. Scramble String

最新推荐文章于 2021-04-17 00:21:09 发布

原创最新推荐文章于 2021-04-17 00:21:09 发布 · 334 阅读

0 ·

CC 4.0 BY-SA版权

leetcode-string 同时被 2 个专栏收录

43 篇文章

订阅专栏

leetcode-dp

6 篇文章

订阅专栏

本文介绍了一种判断两个字符串是否可以通过乱序重组的方式相互转换的方法。通过递归和动态规划两种方式实现，前者通过分解字符串为子问题进行递归判断，后者采用二维动态规划表记录中间结果以提高效率。

字符串分解成两颗子树，子树的长度任意，所有可以用递归

class Solution {
public:
    bool isScramble(string s1, string s2) {
    
        int n=s1.size();
        int m=s2.size();
        int i;
        if(n!=m)
            return false;
        int alp1[26],alp2[26];
        memset(alp1,0,sizeof(alp1));
        memset(alp2,0,sizeof(alp2));
        
        bool same=true;
        for(i=0;i<n;i++)
        {
            if(s1[i]!=s2[i])
                same=false;
            alp1[s1[i]-'a']++;
            alp2[s2[i]-'a']++;
        }
        
        if(same)
            return true;
        for(i=0;i<26;i++)
        {
            if(alp1[i]!=alp2[i])
                return false;
        }
        for(i=1;i<=n-1;i++)
        {
            if(isScramble(s1.substr(0,i),s2.substr(0,i))&&isScramble(s1.substr(i),s2.substr(i))||isScramble(s1.substr(0,i),s2.substr(n-i))&&isScramble(s1.substr(i),s2.substr(0,n-i)))
            return true;
        }
        return false;
    }
};

方法2:

可以使用动态规划，

class Solution {
public:
    bool isScramble(string s1, string s2) {
    
        int n=s1.size();
        int m=s2.size();
        if(n!=m)
            return false;
        if(s1==s2)
            return true;
        bool dp[n][n][n];
        memset(dp,false,sizeof(dp));//s1从i开始，s2从j开始，长度为len 的字符串是否时scramble
        int i,j,k;
        for(i=0;i<n;i++)
        {
            for(j=0;j<n;j++)
                    dp[i][j][1]=(s1[i]==s2[j]);
        }
        
        for(int len=2;len<=n;len++)
        {
            for(i=0;i<=n-len;i++)
                for(j=0;j<=n-len;j++)
                {
                    for(k=1;k<len&&!dp[i][j][len];k++)
                    {
                        dp[i][j][len]=dp[i][j][len]||dp[i][j][k]&&dp[i+k][j+k][len-k]||
                                        dp[i+len-k][j][k]&&dp[i][j+k][len-k]||dp[i][j+len-k][k]&&dp[i+k][j][len-k];
                    }
                }
        }
        return dp[0][0][n];
    }
};