【leetcode热题100】 扰乱字符串

本文主要是介绍【leetcode热题100】 扰乱字符串，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

使用下面描述的算法可以扰乱字符串 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

解法一 递归

开始的时候，由于给出的图示很巧都是平均分的，我以为只能平均分字符串，看了这里，明白其实可以任意位置把字符串分成两部分，这里需要注意一下。

这道题很容易想到用递归的思想去解，假如两个字符串 great 和 rgeat。考虑其中的一种切割方式。

第 1 种情况：S1 切割为两部分，然后进行若干步切割交换，最后判断两个子树分别是否能变成 S2 的两部分。

第 2 种情况：S1 切割并且交换为两部分，然后进行若干步切割交换，最后判断两个子树是否能变成 S2 的两部分。

上边是一种切割方式，我们只需要遍历所有的切割点即可。

public boolean isScramble(String s1, String s2) {if (s1.length() != s2.length()) {return false;}if (s1.equals(s2)) {return true;}//判断两个字符串每个字母出现的次数是否一致int[] letters = new int[26];for (int i = 0; i < s1.length(); i++) {letters[s1.charAt(i) - 'a']++;letters[s2.charAt(i) - 'a']--;}//如果两个字符串的字母出现不一致直接返回 falsefor (int i = 0; i < 26; i++) {if (letters[i] != 0) {return false;}}//遍历每个切割位置for (int i = 1; i < s1.length(); i++) {//对应情况 1 ，判断 S1 的子树能否变为 S2 相应部分if (isScramble(s1.substring(0, i), s2.substring(0, i)) && isScramble(s1.substring(i), s2.substring(i))) {return true;}//对应情况 2 ，S1 两个子树先进行了交换，然后判断 S1 的子树能否变为 S2 相应部分if (isScramble(s1.substring(i), s2.substring(0, s2.length() - i)) &&isScramble(s1.substring(0, i), s2.substring(s2.length() - i)) ) {return true;}}return false;
}

时间复杂度：

空间复杂度：

当然，我们可以用 memoization 技术，把递归过程中的结果存储起来，如果第二次递归过来，直接返回结果即可，无需重复递归。

public boolean isScramble(String s1, String s2) {HashMap<String, Integer> memoization = new HashMap<>();return isScrambleRecursion(s1, s2, memoization);
}public boolean isScrambleRecursion(String s1, String s2, HashMap<String, Integer> memoization) {//判断之前是否已经有了结果int ret = memoization.getOrDefault(s1 + "#" + s2, -1);if (ret == 1) {return true;} else if (ret == 0) {return false;}if (s1.length() != s2.length()) {memoization.put(s1 + "#" + s2, 0);return false;}if (s1.equals(s2)) {memoization.put(s1 + "#" + s2, 1);return true;}int[] letters = new int[26];for (int i = 0; i < s1.length(); i++) {letters[s1.charAt(i) - 'a']++;letters[s2.charAt(i) - 'a']--;}for (int i = 0; i < 26; i++)if (letters[i] != 0) {memoization.put(s1 + "#" + s2, 0);return false; }for (int i = 1; i < s1.length(); i++) {if (isScramble(s1.substring(0, i), s2.substring(0, i)) && isScramble(s1.substring(i), s2.substring(i))) {memoization.put(s1 + "#" + s2, 1);return true;}if (isScramble(s1.substring(0, i), s2.substring(s2.length() - i))&& isScramble(s1.substring(i), s2.substring(0, s2.length() - i))) {memoization.put(s1 + "#" + s2, 1);return true;}}memoization.put(s1 + "#" + s2, 0);return false;}

解法二 动态规划

既然是递归，压栈压栈压栈，出栈出栈出栈，我们可以利用动态规划的思想，省略压栈的过程，直接从底部往上走。

我们用 dp [ len ][ i ] [ j ] 来表示 s1[ i, i + len ) 和 s2 [ j, j + len ) 两个字符串是否满足条件。换句话说，就是 s1 从 i 开始的 len 个字符是否能转换为 S2 从 j 开始的 len 个字符。那么解法一的两种情况，递归式可以写作。

第 1 种情况，参考下图： 假设左半部分长度是 q，dp [ len ][ i ] [ j ] = dp [ q ][ i ] [ j ] && dp [ len - q ][ i + q ] [ j + q ] 。也就是 S1 的左半部分和 S2 的左半部分以及 S1 的右半部分和 S2 的右半部分。

第 2 种情况，参考下图： 假设左半部分长度是 q，那么 dp [ len ][ i ] [ j ] = dp [ q ][ i ] [ j + len - q ] && dp [ len - q ][ i + q ] [ j ] 。也就是 S1 的右半部分和 S2 的左半部分以及 S1 的左半部分和 S2 的右半部分。

public boolean isScramble4(String s1, String s2) {if (s1.length() != s2.length()) {return false;}if (s1.equals(s2)) {return true;}int[] letters = new int[26];for (int i = 0; i < s1.length(); i++) {letters[s1.charAt(i) - 'a']++;letters[s2.charAt(i) - 'a']--;}for (int i = 0; i < 26; i++) {if (letters[i] != 0) {return false;}}int length = s1.length();boolean[][][] dp = new boolean[length + 1][length][length];//遍历所有的字符串长度for (int len = 1; len <= length; len++) {//S1 开始的地方for (int i = 0; i + len <= length; i++) {//S2 开始的地方for (int j = 0; j + len <= length; j++) {//长度是 1 无需切割if (len == 1) {dp[len][i][j] = s1.charAt(i) == s2.charAt(j);} else {//遍历切割后的左半部分长度for (int q = 1; q < len; q++) {dp[len][i][j] = dp[q][i][j] && dp[len - q][i + q][j + q]|| dp[q][i][j + len - q] && dp[len - q][i + q][j];//如果当前是 true 就 break，防止被覆盖为 falseif (dp[len][i][j]) {break;}}}}}}return dp[length][0][0];
}

这篇关于【leetcode热题100】 扰乱字符串的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---