My code:
public class Solution {
public boolean isScramble(String s1, String s2) {
if (s1 == null || s2 == null)
return false;
else if (s1.length() != s2.length())
return false;
else if (!isSame(s1, s2))
return false;
else if (s1.equals(s2))
return true;
/** split string: [0, i), [i, s1.length()) */
for (int i = 1; i < s1.length(); i++) {
String s11 = s1.substring(0, i);
String s12 = s1.substring(i, s1.length());
String s21 = s2.substring(0, i);
String s22 = s2.substring(i, s2.length());
String s23 = s2.substring(s1.length() - i, s1.length());
String s24 = s2.substring(0, s1.length() - i);
if (isScramble(s11, s21) && isScramble(s12, s22))
return true;
if (isScramble(s11, s23) && isScramble(s12, s24))
return true;
}
return false;
}
private boolean isSame(String s1, String s2) {
char[] c1 = s1.toCharArray();
char[] c2 = s2.toCharArray();
Arrays.sort(c1);
Arrays.sort(c2);
s1 = new String(c1);
s2 = new String(c2);
return s1.equals(s2);
}
}
這道題目我是沒有思路的。看了答案之后才有了思路。
這個解法是暴力解法，具體復雜度是多少，我覺得是 2 ^ n
s1, s2, 如果從 i 處切開
那么就比較，
s1[0, i) with s2[0, i) and s1[i, len) with s2[i, len) 是否為scramble
然后這兩個子串可以繼續遞歸下去。
這是一種情況。
第二種情況，
s1[0, i) with s2[len - i, len) and s1[i, len) with s2[0, len - i) 是否為scramble
這兩種情況只要有一種情況是scramble，就return true，否則return false
然后進一步遞歸下去。
復雜度個人估計，O(2 ^ n)
解法2，
Dynamic Programming
My code:
public class Solution {
public boolean isScramble(String s1, String s2) {
if (s1 == null || s2 == null)
return false;
else if (s1.length() != s2.length())
return false;
else if (!isSame(s1, s2))
return false;
else if (s1.equals(s2))
return true;
/** using dp
* dp[i][j]][k] = 1 means s1.substring(i, i + k) and s2.substring(j, j + k) is scramble
*/
int len = s1.length();
int[][][] dp = new int[len][len][len + 1];
/** for single character, if s1(i) == s2(j), then dp[i][j][1] = 1 */
for (int i = 0; i < len; i++) {
for (int j = 0; j < len; j++) {
if (s1.charAt(i) == s2.charAt(j))
dp[i][j][1] = 1;
}
}
/** start at i, j with len, split at k,
* if dp[i][j][k - i] && dp[k][j + k - i][len - (k - i)] is true
* Or dp[i][j + len - (k - i)][k - i] && dp[k][j][len - (k - i)] is true
* then dp[i][j][len] is true
*/
for (int l = 2; l <= len; l++) {
for (int i = 0; i <= len - l; i++) {
for (int j = 0; j <= len - l; j++) {
/** split at offset, i + offset, [i, offset), [i + offset, i + l) */
for (int offset = 1; offset < l; offset++) {
if (dp[i][j][offset] == 1 && dp[i + offset][j + offset][l - offset] == 1)
dp[i][j][l] = 1;
if (dp[i][j + l - offset][offset] == 1 && dp[i + offset][j][l - offset] == 1)
dp[i][j][l] = 1;
}
}
}
}
return dp[0][0][len] == 1;
}
private boolean isSame(String s1, String s2) {
char[] c1 = s1.toCharArray();
char[] c2 = s2.toCharArray();
Arrays.sort(c1);
Arrays.sort(c2);
s1 = new String(c1);
s2 = new String(c2);
return s1.equals(s2);
}
}
這個解法的思路其實和解法1很類似，但是采用了dp
這也是我第一次意識到，dp到底是什么東西。
Dp就是一臺機器，狀態機。你給定，
初始狀態，
一套狀態跳轉到下一個狀態的規則。
然后讓他運行。
固定次數后，出來的結果，或者說，模擬的結果，
就是你要的結果。
所以，dp的關鍵是，
- dp[][] 的物理意義，也有可能是三維數組
- 初始狀態
- 狀態間的轉換規則
dp 的好處是，一旦你找到了這三個，那么，再難的題目，也可以在Np-complete的情況下完成。
但是，問題是，首先，很難抽象出dp的物理意義。
其次，無論情況多么簡單，依然會用最復雜的dp去跑。也就是說，他的運行次數是固定的，不會中途結束或者跳一大段。
- Longest Palindromic Substring
http://www.lxweimin.com/p/4befb2f27ef1
類似于這個，也是dp
greedy的話，就會根據具體情況具體分析，情況好的時候，會跑的很快，不會是一臺規定不變的機器。
參考網頁：
http://blog.csdn.net/ljiabin/article/details/44537523
http://www.jiuzhang.com/solutions/scramble-string/
Anyway, Good luck, Richardo!
My code:
public class Solution {
/**
* @param s1 A string
* @param s2 Another string
* @return whether s2 is a scrambled string of s1
*/
private boolean checkScramble(String s1,int start1, String s2, int start2, int k, int [][][]visit) {
if(visit[start1][start2][k] == 1)
return true;
if(visit[start1][start2][k] ==-1)
return false;
if (s1.length() != s2.length()) {
visit[start1][start2][k] = -1;
return false;
}
if (s1.length() == 0 || s1.equals(s2)) {
visit[start1][start2][k] = 1;
return true;
}
if (!isValid(s1, s2)) {
visit[start1][start2][k] = -1;
return false;
}// Base Cases
for (int i = 1; i < s1.length(); i++) {
String s11 = s1.substring(0, i);
String s12 = s1.substring(i, s1.length());
String s21 = s2.substring(0, i);
String s22 = s2.substring(i, s2.length());
String s23 = s2.substring(0, s2.length() - i);
String s24 = s2.substring(s2.length() - i, s2.length());
if (checkScramble(s11,start1, s21, start2, i, visit) && checkScramble(s12, start1+i, s22, start2+i,k-i, visit)) {
visit[start1][start2][k] = 1;
return true;
}
if (checkScramble(s11,start1, s24, start2+k-i, i, visit) && checkScramble(s12,start1+i, s23,start2, k-i, visit))
{
visit[start1][start2][k] = 1;
return true;
}
}
visit[start1][start2][k] = -1;
return false;
}
public boolean isScramble(String s1, String s2) {
int len = s1.length();
int [][][] visit = new int[len][len][len + 1];
return checkScramble(s1,0,s2,0, len, visit);
}
private boolean isValid(String s1, String s2) {
char[] arr1 = s1.toCharArray();
char[] arr2 = s2.toCharArray();
Arrays.sort(arr1);
Arrays.sort(arr2);
if (!(new String(arr1)).equals(new String(arr2))) {
return false;
}
return true;
}
}
reference：
http://www.jiuzhang.com/solutions/scramble-string/
算是 recursive DP + cache, 復雜度還是在 O(2 ^ n) 左右。
這道題目，加不加cache，最終的效果也差不多。
參考鏈接里，所謂的記憶化搜索，也不過是加了一層cache，
并沒有徹底地改為： iteration DP
但是上面的第二種解法，正是iteration DP,三維的DP
說到底，這道題目還是算是 divide and conquer的一種變形。
Anyway, Good luck, Richardo! -- 08/24/2016
