LeetCode：87. Scramble String - Python

87. 扰乱字符串

问题描述：

给定一个字符串 s1，我们可以把它递归地分割成两个非空子字符串，从而将其表示为二叉树。

下图是字符串s1 = "great"的一种可能的表示形式。

在扰乱这个字符串的过程中，我们可以挑选任何一个非叶节点，然后交换它的两个子节点。

例如，如果我们挑选非叶节点 "gr"，交换它的两个子节点，将会产生扰乱字符串"rgeat"。

我们将"rgeat”称作"great" 的一个扰乱字符串。

示例 1:

输入: s1 = “great”, s2 = “rgeat”
输出: true

示例 2:

输入: s1 = “abcde”, s2 = “caebd”
输出: false

问题分析：

题目的意思是把一个字符串，依次分割，形成一个二叉树的结构，对其非叶子节点进行交换，交换之后继续分割，然后收集起来得到的新字符串，称为原字符串的扰乱字符串。（每次分割的位置是不确定的哦）

（1）题目给出的提示是动态规划，其实感觉更像是递归，反正都是寻找子问题。参考网上的大神给出的解答（链接在下面），进行总结学习。

（2）判断s1和s2是不是互为扰乱字符串，这是一个大问题，那么子问题就是，从某一个位置进行分割，形成新的子串，继续向下判断（从上面的图例上也可以看出来哦）。

（3）因为不知道，分割的位置在哪里，所以要枚举了（循环考虑所有可能的位置）。现在还要考虑两种情况（i 是本次分割的位置）：

1. 本次分割，没有发生交换，所以只考虑(s1[:i], s2[:i]) and (s1[i:], s2[i:]) 这种情况，然后继续向下递归判断。
2. 本次分割，发生交换，所以要考虑(s1[:i], s2[-i:]) and (s1[i:], s2[:-i])这种情况，也就是交换后，两两向下递归判断。

（4）从上面可以看出来，每次要遍历位置，每个位置要考虑两种情况，其实这个递归是非常深的，这是很危险的。现在要考虑剪枝，可以剪枝的地方有：

1. 两个字符串长度是否相等;
2. 两个字符串是否直接相等，如果直接相等，就可以直接返回 true;
3. 两个字符串包含的字符数目是否相等；

Python3实现：

方法一：

class Solution:
    def isScramble(self, s1, s2):
        if len(s1) != len(s2):  # 剪枝
            return False
        if s1 == s2:  # 剪枝
            return True
        if sorted(s1) != sorted(s2):  # 剪枝
            return False
        for i in range(1, len(s1)):  # 两种情况循环递归
            if (self.isScramble(s1[:i], s2[:i]) and self.isScramble(s1[i:], s2[i:])) or \
                    (self.isScramble(s1[:i], s2[-i:]) and self.isScramble(s1[i:], s2[:-i])):
                return True
        return False


if __name__ == '__main__':
    solu = Solution()
    s1, s2 = "great", "rgeat"
    print(solu.isScramble(s1, s2))

方法二：

结合上面的代码以及上面的图例，不难发现一个问题，在递归过程中，会做很多重复的计算，例如要计算两个字符串(s1, s2)是否互为扰乱字符串，可能在其他分支的计算中也会出现这两个字符串的比较操作，所以我们可以把每次计算的到两个字符串的比较结果存放起来，如果在遇到，就直接拿出来使用，这个方法也叫 记忆化搜索(Search Memoization) 可参考链接中的知识补充。这样一来，可以节省一部分计算时间，但也会多开销一些空间。

class Solution:
    def __init__(self):
        self.dic = {}

    def isScramble(self, s1, s2):
        if (s1, s2) in self.dic:
            return self.dic[(s1, s2)]
        if len(s1) != len(s2) or sorted(s1) != sorted(s2):  # 剪枝
            self.dic[(s1, s2)] = False
            return False
        if s1 == s2:
            self.dic[(s1, s2)] = True
            return True
        for i in range(1, len(s1)):  # 两种情况循环递归
            if (self.isScramble(s1[:i], s2[:i]) and self.isScramble(s1[i:], s2[i:])) or \
                    (self.isScramble(s1[:i], s2[-i:]) and self.isScramble(s1[i:], s2[:-i])):
                return True
        self.dic[(s1, s2)] = False
        return False


if __name__ == '__main__':
    solu = Solution()
    s1, s2 = "great", "rgeat"
    print(solu.isScramble(s1, s2))

方法三：

class Solution:
    def isScramble(self, s1: str, s2: str) -> bool:
        @cache
        def dfs(i1: int, i2: int, length: int) -> bool:
            """
            第一个字符串从 i1 开始，第二个字符串从 i2 开始，子串的长度为 length，是否和谐
            """

            # 判断两个子串是否相等
            if s1[i1:i1+length] == s2[i2:i2+length]:
                return True
            
            # 判断是否存在字符 c 在两个子串中出现的次数不同
            if Counter(s1[i1:i1+length]) != Counter(s2[i2:i2+length]):
                return False
            
            # 枚举分割位置
            for i in range(1, length):
                # 不交换的情况
                if dfs(i1, i2, i) and dfs(i1 + i, i2 + i, length - i):
                    return True
                # 交换的情况
                if dfs(i1, i2 + length - i, i) and dfs(i1 + i, i2, length - i):
                    return True
        
            return False

        ans = dfs(0, 0, len(s1))
        dfs.cache_clear()
        return ans

声明： 总结学习，有问题或不当之处，可以批评指正哦，谢谢。

题目链接、参考链接