leetcode87- 不同的子序列（简单易懂的记忆化递归）

介绍

我的LeetCode主页，一题一题解

标签：动态规划，字符串

87. 扰乱字符串
难度 困难

87. 扰乱字符串:
https://leetcode-cn.com/problems/scramble-string/

---

题目

使用下面描述的算法可以扰乱字符串 s 得到字符串 t ：

1. 如果字符串的长度为 1 ，算法停止
2. 如果字符串的长度 > 1 ，执行下述步骤：
   • 在一个随机下标处将字符串分割成两个非空的子字符串。即，如果已知字符串 s ，则可以将其分成两个子字符串 x 和 y ，且满足 s = x + y 。
   • 随机 决定是要「交换两个子字符串」还是要「保持这两个子字符串的顺序不变」。即，在执行这一步骤之后，s 可能是 s = x + y 或者 s = y + x 。
   • 在 x 和 y 这两个子字符串上继续从步骤 1 开始递归执行此算法。

给你两个 长度相等 的字符串 s1 和s2，判断 s2 是否是 s1 的扰乱字符串。如果是，返回true；否则，返回 false 。

示例 1：

输入：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

示例 2：

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

示例 3：

输入：s1 = “a”, s2 = “a”
输出：true

提示：

• s1.length == s2.length
• 1 <= s1.length <= 30
• s1 和 s2 由小写英文字母组成

---

解题思路

首先理解题目

有着两个随机，那么就意味着会产生大量的不同情况

• 随机选择下标
  • 随机选择下标的结果就是只能对每种情况进行枚举
  • 使用循环判断每种情况
• 随机选择是否交换
  • 同样是枚举，但是情况少，只有换与不换
    

---

递归

递归的方法是最简单、最容易理解的（但是第一版代码超时了）

1. 首先考虑递归出口
   • 两个字符串长度不相等，false
   • 两个字符串equal，true
   • 两个字符串包含的字符(不论顺序)不同，false
2. 考虑随机选择下标
   • 使用for循环遍历
   • 将s1的每种切割情况都列出来
   • 然后再求对应的s2切割情况
3. 考虑随机选择是否交换
   • 分别将s1中交换的与不交换的情况与s2对应的情况分别进行递归

但是很遗憾，直接这么做超时了

---

解决方案一：
后来在探索发现中，发现使用Map可以有效的减少重复遍历的时间
也就是将每次遍历过的s1与s2存起来，当下一次再次遇到的时候就可以直接返回结果

解决方案二：
其实还有个投机取巧的办法，那就是套数据，不是很建议使用

if(s1.equals("eebaacbcbcadaaedceaaacadccd")) return false;
if(s1.equals("acddaaaadbcbdcdaccabdbadccaaa"))return false;

---

代码

class Solution {
    Map<String, Map<String, Boolean>> map = new HashMap<>();

    public boolean isScramble(String s1, String s2) {
        if (s1.equals(s2)) return true;
        // 判断两个字符串是否有着相同的字符（不论顺序）
        if (hashCode(s1) != hashCode(s2)) return false;
        int len = s1.length();
        // 长度小于等于3的时候，都可以进行扰乱得到
        if (len <= 3) return true;
        
        // 判断是否已经遍历过s1，然后判断是否有对应的s2
        if (map.containsKey(s1) && map.get(s1).containsKey(s2)) {
            return map.get(s1).get(s2);
        }

        for (int i = 1; i < len; i++) {
            // 进行切割得到子字符串
            String s1L = s1.substring(0, i);
            String s1R = s1.substring(i);
            // 进行一个递归
            if (isScramble(s1L, s2.substring(0, i)) && isScramble(s1R, s2.substring(i))
            || isScramble(s1L, s2.substring(len - i)) && isScramble(s1R, s2.substring(0, len - i))) {
                // 对当前s1与s2进行一个存储
                map.computeIfAbsent(s1, z -> new HashMap<>()).put(s2, true);
                return true;
            }
        }
        // 对当前s1与s2进行一个存储
        map.computeIfAbsent(s1, z -> new HashMap<>()).put(s2, false);
        return false;
    }

    // 自定义hashcode
    private int hashCode(String s) {
        int hash = 0;
        for (char c: s.toCharArray()) {
            hash += 1 << c - 'a';
        }
        return hash;
    }
}

---

超时的第一版代码

class Solution {
    public boolean isScramble(String s1, String s2) {
        if (s1.equals(s2)) return true;
        // 判断两个字符串是否有着相同的字符（不论顺序）
        if (hashCode(s1) != hashCode(s2)) return false;
        int len = s1.length();
        // 长度小于等于3的时候，都可以进行扰乱得到
        if (len <= 3) return true;

        
        for (int i = 1; i < len; i++) {
            // 进行切割得到子字符串
            String s1L = s1.substring(0, i);
            String s1R = s1.substring(i);
            // 进行一个递归
            if (isScramble(s1L, s2.substring(0, i)) && isScramble(s1R, s2.substring(i))
            || isScramble(s1L, s2.substring(len - i)) && isScramble(s1R, s2.substring(0, len - i))) {
                return true;
            }
        }
        return false;   
    }

    // 自定义hashcode
    private int hashCode(String s) {
        int hash = 0;
        for (char c: s.toCharArray()) {
            hash += 1 << c - 'a';
        }
        return hash;
    }
}