持续创作，加速成长！这是我参与「掘金日新计划 · 6 月更文挑战」的第30天，点击查看活动详情
题目描述
使用下面描述的算法可以扰乱字符串 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 。
示例 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
递归+HashMap
这个题目我的初步思路是：最容易想到的办法就是，将str2从每个可以分割的点分割成两个部分，结果与str1正反分割的部分进行对比，之后对分割下来的部分进行递归对比，在用map来做记忆化缓存。步骤如下：
- 唯一的（s1，s2）字符串对按先大后小的规律组合后的s肯定也是唯一的，因此以s作为map的key。
- 从前往后每个间隙都判断是否有子串“相等”，且因为存在交换的可能，故还要从后往前遍历s2，同时用一个数组记录
- 判断子串是否“相等”。只要有一种情况下子串相等，就就进入子串的递归判断
- s1和s2的靠左的子串“相等”，即没有发生旋转交换
- 因为长度小于4的字符串只要其中的字符是一样的，那一定是互为扰乱字符串，因此先判断靠右的子串，若靠左的子串长度大于3，则再判断靠左的子串
- 靠左的子串和s2靠右的子串“相等”，即发生旋转交换
class Solution {
Map<String, Boolean> map;
public boolean isScramble(String s, String t) {
map = new HashMap<>();
return dfs(s, t);
}
private boolean dfs(String s, String t) {
if (s.length() != t.length()) return false;
if (s.equals(t)) return true;
if (!check(s, t)) return false;
String key = s + "_" + t;
if (map.containsKey(key)) return map.get(key);
int n = s.length();
for (int i = 1; i < n; i++) {
String x = s.substring(0, i), y = s.substring(i);
String a = t.substring(0, i), b = t.substring(i);
String c = t.substring(0, n - i), d = t.substring(n - i);
if (dfs(x, a) && dfs(y, b) || dfs(x, d) && dfs(y, c)) {
map.put(key, true);
return true;
}
}
map.put(key, false);
return false;
}
public boolean check(String s, String t) {
int[] cnt = new int[26];
for (char c : s.toCharArray())
cnt[c - 'a']++;
for (char c :t.toCharArray())
cnt[c - 'a']--;
for (int count : cnt)
if (count != 0) return false;
return true;
}
}
最后
吐了，做了好久才写出来。试了好几个字符串才发现规律：要想是扰乱字符串，必须满足两个字符串各自在某处一分为二后，s1两个子串分别“等于”s2的两个子串，这里的“等于”意思是两个字符串拥有一模一样的字母，只是顺序不同罢了。当满足这个条件后就继续判断“相等”的子串，而子串的判断方法和父串一样的，这里明显需要采用递归。
