题目描述
题目链接:https://leetcode-cn.com/problems/scramble-string/
87. 扰乱字符串
使用下面描述的算法可以扰乱字符串 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
示例 2:
输入:s1 = "abcde", s2 = "caebd"
输出:false
示例 3:
输入:s1 = "a", s2 = "a"
输出:true
提示:
s1.length == s2.length
1 <= s1.length <= 30
s1 和 s2 由小写英文字母组成
通过次数27,889提交次数57,856
题解
本人比较懒,所以就懒得解释了,直接上代码啦!
普通的递归(超时)
class Solution1 {
public boolean isScramble(String s1, String s2) {
if (s1.length() == 1) {
return s1.equals(s2);
}
if (s1.length() != s2.length()) {
return false;
}
char[] cs1 = s1.toCharArray();
char[] cs2 = s1.toCharArray();
int[] cnt1 = new int[128];
int[] cnt2 = new int[128];
for (char c : cs1) {
++cnt1[c];
}
for (char c : cs2) {
++cnt2[c];
}
if (Arrays.equals(cnt1, cnt2)) {
int len = s1.length();
int mid;
for (mid = 1; mid < len; ++mid) {
if ((isScramble(s1.substring(0, mid), s2.substring(0, mid)) && isScramble(s1.substring(mid), s2.substring(mid))) ||
(isScramble(s1.substring(0, mid), s2.substring(len - mid)) && isScramble(s1.substring(mid), s2.substring(0, len - mid)))) {
return true;
}
}
}
return false;
}
}
区间DP
class Solution2 {
public boolean isScramble(String s1, String s2) {
char[] cs1 = s1.toCharArray(); //字符串s1的char数组表示形式
char[] cs2 = s2.toCharArray(); //字符串s2的char数组表示形式
int m = cs1.length;
int n = cs2.length;
if (m != n) {
return false; // 长度不等,s2不可能由s1得到
}
boolean[][][] dp = new boolean[m][n][n + 1]; //dp[s1的起始索引][s2起始索引][长度]
//先处理长度为1的情况
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
dp[i][j][1] = cs1[i] == cs2[j];
}
}
//再处理长度为其他的情况
for (int len = 2; len <= m; len++) {
//第一层循环:长度
for (int i = 0; i <= m - len; i++) {
//第二层循环:遍历cs1
for (int j = 0; j <= n - len; j++) {
//第三层循环:遍历cs2
for (int l = 1; l < len; l++) {
//第四层循环:计算
boolean a = dp[i][j][l] && dp[i + l][j + l][len - l];
boolean b = dp[i][j + len - l][l] && dp[i + l][j][len - l];
if (a || b) {
dp[i][j][len] = true;
break;
}
}
}
}
}
return dp[0][0][n];
}
}
记忆化递归
class Solution {
char[] cs1 = null;
char[] cs2 = null;
int[][][] dp; //dp[s1的起始索引][s2起始索引][长度] ==> 0:不确定,1:true,2:false
int n; //cs1的长度
public boolean isScramble(String s1, String s2) {
this.cs1 = s1.toCharArray();
this.cs2 = s2.toCharArray();
if (cs1.length != cs2.length) {
return false;
}
this.n = cs1.length;
this.dp = new int[n][n][n + 1];
return dfs(0,0,n);
}
/*
判断从s1[i]开始len个长度能否转换成s2[j]开始len个长度的字符串
*/
private boolean dfs(int i, int j, int len) {
if(len == 1){
return cs1[i] == cs2[j];
}
if (dp[i][j][len] != 0) {
return dp[i][j][len] == 1;
}
for (int k = 1; k < len; ++k) {
if ((dfs(i, j, k) && dfs(i + k, j + k, len - k)) || (dfs(i, j + len - k, k) && dfs(i + k, j, len - k))){
dp[i][j][len] = 1;
return true;
}
}
dp[i][j][len] = 2;
return false;
}
}