leetcode 87. 扰乱字符串

87. 扰乱字符串

给出两个长度相等的字符串 s1 和 s2，判断 s2 是否是 s1 的扰乱字符串。

示例 1:

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

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

递归

• 如果 T和 S 长度不一样，必定不能变来
• 如果长度一样，顶层字符串 S 能够划分为 S1和 S2，同样字符串 T 也能够划分为 T1和 T2
  • 情况一：没有交换: S1->T1, S2->T2
  • 情况二：交换过: S1->T2, S2->T1
    由于这是一种树型的结构，所以我们考虑使用递归进行求解：
• 递归弹出条件 两者相等，返回True; 字符上肯定不能构成返回False;
• 开始对每一个可能的分割点进行遍历递归， 只要有一种情况为真都返回True;否则返回False

from typing import List
class Solution:
    def isScramble(self, s1: str, s2: str) -> bool:
      if s1 == s2:
        return True
      if sorted(s1) != sorted(s2):
        return False
      n = len(s1)

      for i in range(1, n):#之前对全等状态判断多了，这里从1开始
        if self.isScramble(s1[:i], s2[:i]) and self.isScramble(s1[i:], s2[i:]):
          return True
        if self.isScramble(s1[:i], s2[-i:]) and self.isScramble(s1[i:], s2[:-i]):
          return True
      return False

动态规划

dp[i][j][len] 表示从字符串 S 中 i 开始长度为 len 的字符串是否能变换为从字符串 T 中 j 开始长度为 len 的字符串，
所以答案是 dp[0][0][n]。 时间复杂度 O(N^4 )，空间复杂度O(N^3)

• 建立一个三维DP，大小为 n x n x (n+1), dp[i][j][l],表示字符串S[i:i+l]与字符串T[j:j+l]是否满足扰乱关系。
• 建立的时候所有值都是False; 初始化在立方体的底面，也就是字符串单个字符与另一个字符串单个字符的关系。
• dp推理：进行枚举
  • 枚举字符长度2-n中的索引 k
  • 枚举S中的起始位置 i
  • 枚举T中的起始位置 j
  • 枚举划分的位置 w
  • 枚举两种扰乱的情况

#使用动态规划做， dp[i][j][l] 表示s1[i:i+l] == s2[j:j+l]
class Solution:
    def isScramble(self, s1: str, s2: str) -> bool:
      n = len(s1)
      #判断一些特数的情况
      if s1 == s2: return True
      if len(s2) != n: return False
      if sorted(s1) != sorted(s2): return False
      #为三维dp数组赋初值False  数组大小n*n*(n+1)
      dp = [[[False] * (n+1) for _ in range(n)] for _ in range(n)]
      #首先对单个字符进行判断,相当于立方体最下面的地面，字符两两对应相交
      #动态规划就是根据之前的状态来计算当前状态，所以需要计算一个初始值
      for i in range(n):
        for j in range(n):
          dp[i][j][1] = s1[i] == s2[j]
      
      for k in range(2, n+1):#字符长度为[2-n]的情况,即s1[:k] s1[k:],枚举区间长度
        for i in range(n - k + 1):#枚举起始位置
          for j in range(n - k + 1):#枚举起始位置
            for w in range(1, k):#枚举划分的位置（两种情况）
              if dp[i][j][w] and dp[i+w][j+w][k-w]:#相同位置的情况
                dp[i][j][k] = True
                break
              if dp[i+w][j][k-w] and dp[i][j+k-w][w]:#交叉位置的情况
                dp[i][j][k] = True
                break
      return dp[0][0][n]


if __name__ == "__main__":
    s = Solution()
    print(s.isScramble("tar", "atr"))