Leetcode-87 扰乱字符串

这一题还是没有什么思路，但是在看完题解后才发现，原来是被题目描述给吓到了，其实没有想象中的那么难，其使用的算法是搜索。

题目描述

使用下面描述的算法可以扰乱字符串 s 得到字符串 t ：
如果字符串的长度为 1 ，算法停止
如果字符串的长度 > 1 ，执行下述步骤：
在一个随机下标处将字符串分割成两个非空的子字符串。即，如果已知字符串 s ，则可以将其分成两个子字符串 x 和 y ，且满足 s = x + y 。
随机 决定是要「交换两个子字符串」还是要「保持这两个子字符串的顺序不变」。即，在执行这一步骤之后，s 可能是 s = x + y 或者 s = y + x 。
在 x 和 y 这两个子字符串上继续从步骤 1 开始递归执行此算法。
给你两个 长度相等 的字符串 s1 和 s2，判断 s2 是否是 s1 的扰乱字符串。如果是，返回 true ；否则，返回 false 。

输入：s1 = "great", s2 = "rgeat"
输出：true
解释：s1 上可能发生的一种情形是：
"great" --> "gr/eat" // 在一个随机下标处分割得到两个子字符串
"gr/eat" --> "gr/eat" // 随机决定：「保持这两个子字符串的顺序不变」
"gr/eat" --> "g/r / e/at" // 在子字符串上递归执行此算法。两个子字符串分别在随机下标处进行一轮分割
"g/r / e/at" --> "r/g / e/at" // 随机决定：第一组「交换两个子字符串」，第二组「保持这两个子字符串的顺序不变」
"r/g / e/at" --> "r/g / e/ a/t" // 继续递归执行此算法，将 "at" 分割得到 "a/t"
"r/g / e/ a/t" --> "r/g / e/ a/t" // 随机决定：「保持这两个子字符串的顺序不变」
算法终止，结果字符串和 s2 相同，都是 "rgeat"
这是一种能够扰乱 s1 得到 s2 的情形，可以认为 s2 是 s1 的扰乱字符串，返回 true

解答

从这一题的描述中我们可以发现，其实质就是将一个字符串不断的分割成两个子串，每次分割，分割得到的两个子串的位置有可能变化也有可能不变。
根据题目描述，字符串s2是由字符串s1根据要求转化而来。假设s1的第一次分割是在下标为 i 处分割，则下一次的分割分别在[0, i] 与 [i + 1, len](假设s1长度为len) 。再下一次的分割则分别在两个子串中进行，两子串间互不干涉。反映到本题，则是s1的[0, i] 与s2的[0, i] 对应，或者s1的[0, i] 与s2的[len - i, len]对应。则接下来则是对两个子串进行相同的处理。到这里，其实问题已经分析完了，下一步的问题在于如何判断子串对应。其对应的条件就是对应子串相等。当相等后，就可以返回该子串判断结果。
需要注意的有两点，首先是在搜索的时候需要用记忆化，否则会超时。对于这种情况，难点在于设置合适的数组来进行记录。本题建立了三维数组，array[a][b][c]。a代表s1字符串的子串是从 a 开始，b代表s2字符串的子串是从 b 开始，c 代表子串长度为c。相当于记录了两个向量(a, c)、(b, c)，分别是地址从a、b开始，长度为c的子串。
第二点是为了方便起见，我们可以对两子串进行排序，排序后的结果不一致的话可以直接判断为false。这一步会节省大量运行时间。因为排序的时间复杂度为O(logN)，而深搜的时间复杂度为O(N^3)。而往往一般不对应的子串排序后的结果是不一致的。
具体代码如下所示：

class Solution {
public:
    int array[35][35][35];
    bool dfs(string s1, string s2, int a, int b, int len){
        if(array[a][b][len] != 0)
            return array[a][b][len] == 1;
        string str1 = s1.substr(a, len);
        string str2 = s2.substr(b, len);
        if(str1 == str2){
            array[a][b][len] = 1;
            return true;
        }
        sort(str1.begin(), str1.end());
        sort(str2.begin(), str2.end());
        if(str1 != str2){
            array[a][b][len] = -1;
            return false;
        }
        for(int i = 1; i < len; i++){
            bool a1 = dfs(s1, s2, a + i, b + i, len - i) && dfs(s1, s2, a, b, i);
            bool a2 = dfs(s1, s2, a, b + len - i, i) && dfs(s1, s2, a + i, b, len - i);
            if(a1 || a2){
                array[a][b][len] = 1;
                return true;
            }
        }
        array[a][b][len] = -1;
        return false;
    }

    bool isScramble(string s1, string s2) {
        memset(array, 0, sizeof(array));
        return dfs(s1, s2, 0, 0, s1.size());
    }
};