LeetCode87扰乱字符串
程序员文章站
2022-04-27 08:52:24
...
读题
在扰乱这个字符串的过程中,我们可以挑选任何一个非叶节点,然后交换它的两个子节点。
说明,字符串相同时,输出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']--;
}
//如果两个字符串的字母出现不一致直接返回 false
for (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;
}
动态规划
初步分析
给定两个字符串 T 和 S,假设 T 是由 S 变换而来
如果 T 和 S 长度不一样,必定不能变来
如果长度一样,顶层字符串 S 能够划分为 S1和 S2同样字符串 T 也能够划分为 T1和 T2
情况一:没交换,S1 ==> T1,S2 ==> T2
情况二:交换了,S1 ==> T2,S2 ==> T1
确定子问题
子问题就是分别讨论两种情况,T1是否由 S1变来,T1是否由 S2 变来,或 T1是否由 S2变来,T2 是否由 S1变来。
初始条件
对于长度是 1 的子串,只有相等才能变过去,相等为 true,不相等为 false。
得到答案
还记得我们的定义吗?dp [ len ][ i ] [ j ] 表示从字符串 S 中 i 开始长度为 len 的字符串是否能变换为从字符串 T 中 j 开始长度为 len 的字符串,所以答案是 dp [ length ][ 0] [ 0 ] 。
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,防止被覆盖为 false
if (dp[len][i][j]) {
break;
}
}
}
}
}
}
return dp[length][0][0];
}
补充
// 上述代码只是考虑了16个英文字母,可以用hashmap来代替
int n = s1.length();
HashMap<Character, Integer> map = new HashMap<>();
for (int i = 0; i < n; i++) {
char c1 = s1.charAt(i);
char c2 = s2.charAt(i);
map.put(c1, map.getOrDefault(c1, 0) + 1);
map.put(c2, map.getOrDefault(c2, 0) - 1);
}
for (Character key : map.keySet()) {
if (map.get(key) != 0) {
return false;
}
}