本文深入探讨了Scramble字符串问题，通过递归和动态规划两种方法详细讲解了解决方案，并提供了易于理解的代码实现。
https://oj.leetcode.com/problems/scramble-string/
Given a string s1, we may represent it as a binary tree by partitioning it to two non-empty substrings recursively.
Below is one possible representation of s1 = "great":
great
/ \
gr eat
/ \ / \
g r e at
/ \
a t
To scramble the string, we may choose any non-leaf node and swap its two children.
For example, if we choose the node "gr" and swap its two children, it produces a scrambled string "rgeat".
rgeat
/ \
rg eat
/ \ / \
r g e at
/ \
a t
We say that "rgeat" is a scrambled string of "great".
Similarly, if we continue to swap the children of nodes "eat" and "at", it produces a scrambled string "rgtae".
rgtae
/ \
rg tae
/ \ / \
r g ta e
/ \
t a
We say that "rgtae" is a scrambled string of "great".
Given two strings s1 and s2 of the same length, determine if s2 is a scrambled string of s1.
public boolean isScramble(String s1, String s2)
这一题，和find median in two sorted array在我眼里是并列oj所有题目top 2难度的，这一题同时也是oj里面目前为止最难的，也是唯一的三维DP。
当然，跟以往一样，在给出dp解之前，我会给出一个可以AC的暴力递归截枝解。
这题暴力的做法其实不是很难。主要是在每一个递归层级的当前s1和s2 中，遍历一个分界点，也就是取一个i， 0 < i < s.length()，然后进行两次分组。
第一个分组是s1[0.. i - 1], s2[0.. i - 1]的搭配以及s1[i...s1.length() - 1], s2[i...s2.length() - 1]的搭配
第二个分组是s1[0...i - 1] s2[s2.length() - i , s2.length() - 1]的搭配以及s1[i.. s1.length() - 1]. s2[0... s2.length() - i - 1]的搭配。
以上两组共四个搭配分别往下递归。也就是每组两次，分别两组递归。当第一组可以返回true的时候就不需要进行第二组了，接下来的分割也是不需要了。因为找到一组合理的就可以了。
当所有分割分组的递归都没办法返回true的时候就只能返回false了。这个递归的base case是搭配的子字符串相等即返回true。
至于截枝的方法，只能在每次开展循环分割并递归的之前，判断s1和s2的字符数目是否相等。如果不相等直接返回false就可以了。
下面给出暴力的代码：
public boolean isScramble(String s1, String s2) {
if(s1.length() != s2.length())
return false;
return helper(s1, s2);
}
public boolean helper(String s1, String s2){
if(s1.equals(s2))
return true;
int[] counter = new int[26];
for(int i = 0; i < s1.length(); i++){
counter[s1.charAt(i) - 'a']++;
}
for(int i = 0; i < s2.length(); i++){
counter[s2.charAt(i) - 'a']--;
}
for(int i : counter){
if(i != 0)
return false;
}
for(int i = 1; i < s1.length(); i++){
String s11 = s1.substring(0, i), s12 = s1.substring(i), s21 = s2.substring(0, i), s22 = s2.substring(i);
if(helper(s11, s21) && helper(s12, s22))
return true;
String s23 = s2.substring(0, s1.length() - i), s24 = s2.substring(s1.length() - i);
if(helper(s11, s24) && helper(s12, s23))
return true;
}
return false;
}首先给出f(i, j, k)的定义，就是当s1以第i个字母开始，s2以第j个字母开始，k长度的子串是否是scrambled的。
那么这个dp的base case是f(i, j , 1) = s1[i] == s2[j].
那么在k >= 2的环境里f(i,j,k) = f(i,j, m) && f(i + m,j + m, k - m) || f(i, j + k - m, m) && f(i + m, j, k - m) ( 1 <= m < k)
其实上述的推导式里面在我们的暴力递归式就已经可以看到了。具体就不详述了，
public boolean isScramble(String s1, String s2) {
if(s1.length() != s2.length())
return false;
boolean[][][] dp = new boolean[s1.length()][s1.length()][s1.length() + 1];
for(int i = 0; i < s1.length(); i++){
for(int j = 0; j < s2.length(); j++){
dp[i][j][1] = s1.charAt(i) == s2.charAt(j);
}
}
for(int len = 2; len <= s1.length(); len++){
for(int i = 0; i <= s1.length() - len; i++){
for(int j = 0; j <= s2.length() - len; j++){
for(int k = 1; k < len; k++){
dp[i][j][len] |= (dp[i][j][k] && dp[i + k][j + k][len - k]) // 相当于brute force的正向比较
|| (dp[i][j + len - k][k] && dp[i + k][j][len - k]);// brute force的反向比较
}
}
}
}
return dp[0][0][s1.length()];
}2017-12-19 Updated:
鉴于我对这题的解法失去了印象。我认为这是我当初没有理解题目而生搬算法造成的。所以我稍微修改了一下recursive的代码。
public boolean isScramble(String s1, String s2) {
if(s1.length() != s2.length())
return false;
return helper(s1, s2);
}
public boolean helper(String s1, String s2){
if(s1.equals(s2))
return true;
int[] counter = new int[26];
for(int i = 0; i < s1.length(); i++){
counter[s1.charAt(i) - 'a']++;
}
for(int i = 0; i < s2.length(); i++){
counter[s2.charAt(i) - 'a']--;
}
for(int i : counter){
if(i != 0)
return false;
}
for(int i = 1; i < s1.length(); i++){
String s11 = s1.substring(0, i), s12 = s1.substring(i), s21 = s2.substring(0, i), s22 = s2.substring(i);
if(helper(s11, s21) && helper(s12, s22))
return true;
String s13 = s1.substring(s1.length() - i), s14 = s1.substring(0, s1.length() - i);
if(helper(s13, s21) && helper(s14, s22))
return true;
}
return false;
} 值得关注的是在这段代码里，第二段的比较里面我不再对s2做subtring的处理而是对s1进行第二次的substring处理。这更符合题目对于scramble string的定义，我们永远要将s1拆解为树才好。在这个recursion里，第一个if所表示的是将s1遍历位置将当前layer的子字符串分为左右两个分枝节点但不交换。s13和s14则是从右边开始取同样长度的两个分枝节点并且交换(scramble)。原理就是这样。
而且若非是要截肢。本身这一题的base case本身应该不是统计字符数目是否相等。而是根据题意一样，如若节点长度为一的情况下仍然不相等，这也匹配了dp解里面的base case的处理。但是为了效率和截肢，遂采取这样的做法，而且此种做法同时也可以比较出节点长度为一且不等的情况。
下面给出一段附带注释，而且匹配上面只修改s1不修改s2的代码：
public boolean isScramble(String s1, String s2) {
if (s1.length() != s2.length()) return false;
boolean[][][] dp = new boolean[s1.length()][s1.length()][s1.length() + 1];
for(int i = 0; i < s1.length(); i++) {
for (int j = 0; j < s2.length(); j++)
// Base case : 单字符是否匹配。
dp[i][j][1] = s1.charAt(i) == s2.charAt(j);
}
for (int len = 2; len <= s1.length(); len++) {
for (int i = 0; i <= s1.length() - len; i++) {
for(int j = 0; j <= s2.length() - len; j++) {
for (int k = 1; k < len; k++) {
// 基本和Brute force一样。
// k是分割点，比较的方式就是从最左分割到最右。譬如"abcd"就是循环k就是分割出("a", "bcd") ("ab", "cd") ("abc", "d")三组
// dp[i][j][k] && dp[i + k][j + k][len - k]表示从中间截断之后的正向比较，也就是子节点没有进行交换
// ex s1 = "abcd" s2 = "abcd" k = 1的时候就相当于左边是"a"和"a"比，右边是"bcd"和"bcd"比
// dp[i + len - k][j][k] && dp[i][j + k][len - k] 表示中间截断之后的反向比较，也就是子节点进行了交换
// ex s1 = "bcda" s2 = "abcd" k = 1的时候就相当于s1最右边的"a"和s2最左边的"a"，然后s1左边数len - k个字符也就是3个字符"bcd"和s2右边的"bcd"
dp[i][j][len] |= (dp[i][j][k] && dp[i + k][j + k][len - k]) || (dp[i + len - k][j][k] && dp[i][j + k][len - k]);
}
}
}
}
return dp[0][0][s1.length()];
}
扫一扫
401
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
