87. Scramble String

▶ 将一个单词 W1 以字母为最小单位拆成一棵二叉树，旋转其中的某几个结点的左右子树，再拼装回去得到单词 W2，我们称 W1 与 W2 等价。现在给出两个单词，判定他们是否等价。

● 代码，4 ms，递归，最快的解法算法与之相同。有方法利用 unordered_map 缓存了各子串的判定结果，但由于子串情况数较多，反而减速为 75 ms

class Solution
{
public:
    bool isScramble(string s1, string s2)
    {
        if (s1 == s2)// 先做一些简单的比较，诸如字符数、每种字符的个数
            return true;
        if (s1.size() != s2.size())
            return false;
        int i, len, count[26] = { 0 };
        for (i = 0, len = s1.size(); i < len; i++)
        {
            count[s1[i] - 'a']++;
            count[s2[i] - 'a']--;
        }
        for (i = 0; i < 26; i++)
        {
            if (count[i])
                return false;
        }
        for (i = 1; i <= len - 1; i++)
        {
            if (isScramble(s1.substr(0, i), s2.substr(0, i)) && isScramble(s1.substr(i), s2.substr(i)))// 前半段跟前半段比，后半段跟后半段比
                return true;
            if (isScramble(s1.substr(0, i), s2.substr(len - i)) && isScramble(s1.substr(i), s2.substr(0, len - i)))// 前半段跟后半段比，后半段跟前半段比
                return true;
        }
        return false;
    }
};

 ● 代码，41 ms，三维动态规划，时间复杂度 O(n⁴)

class Solution
{
public:
    bool isScramble(string s1, string s2)
    {
        const int sSize = s1.size();
        int len, i, j, k;
        if (sSize == 0)
            return true;
        if (sSize == 1)
            return s1 == s2;
        vector<vector<vector<bool>>> isS(sSize + 1, vector<vector<bool>>(sSize, vector<bool>(sSize, false)));
            // sS[i][j][k] 表示的是从 s1[j] 和 s2[k] 开始的长为 i 的子串，是否等价
        for (i = 0; i < sSize; i++)
        {
            for (j = 0; j < sSize; j++)
                isS[1][i][j] = s1[i] == s2[j];
        }
        for (len = 2; len <= sSize; len++)// 每次循环填充一层
        {
            for (i = 0; i <= sSize - len; i++)
            {
                for (j = 0; j <= sSize - len; j++)
                {
                    for (k = 1; k < len && !isS[len][i][j]; k++)
                    {
                        isS[len][i][j] = isS[len][i][j] || (isS[k][i][j] && isS[len - k][i + k][j + k]);
                        isS[len][i][j] = isS[len][i][j] || (isS[k][i + len - k][j] && isS[len - k][i][j + k]);
                    }
                }
            }
        }
        return isS[sSize][0][0];
    }
};

 ● 动态规划的另一个版本，31 ms

class Solution
{
public:
    bool isScramble(string s1, string s2)
    {
        if (s1.size() != s2.size())
            return false;
        const int len = s1.length();        
        vector<vector<vector<bool>>> F(len, vector<vector<bool>>(len, vector<bool>(len + 1, false)));
        // F(i, j, k) 表示从s1[i] 和 s2[j] 开始的长为 k 的子串是否等价
        // 使用长度 q 来切割上述子串（q < k），分前半段、后半段分别对应的两种情况进行讨论       
        // s1 [   x1    |         x2         ]
        //    i         i + q                i + k - 1
        // s2 [   y1    |         y2         ]
        //    j         j + q                j + k - 1
        // s2 [       y1        |     y2     ]
        //    j                 j + k - q    j + k - 1
        // 对于 k = 1，仅需检验 s1[i] 和 s2[j] 
        // 对于 k > 1 和 1 <= q < k，需要讨论 F(i, j, k) = (F(i, j, q) && F(i + q, j + q, k - q)) || (F(i, j + k - q, q) && F(i + q, j, k - q));       
        for (int k = 1; k <= len; ++k)
        {
            for (int i = 0; i + k <= len; ++i)
            {
                for (int j = 0; j + k <= len; ++j)
                {
                    if (k == 1)
                        F[i][j][k] = s1[i] == s2[j];
                    else
                    {
                        for (int q = 1; q < k && !F[i][j][k]; ++q)
                        {
                            F[i][j][k] = (F[i][j][q] && F[i + q][j + q][k - q]) || (F[i][j + k - q][q] && F[i + q][j][k - q]);
                        }
                    }
                }
            }
        }
        return F[0][0][len];
    }
};