原题网址:https://leetcode-cn.com/problems/scramble-string/description/
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.
分析:
由于一个字符串有很多种二叉表示法,貌似很难判断两个字符串是否可以做这样的变换。
对付复杂问题的方法是从简单的特例来思考,从而找出规律。
先考察简单情况:
字符串长度为1:很明显,两个字符串必须完全相同才可以。
字符串长度为2:当s1="ab", s2只有"ab"或者"ba"才可以。
对于任意长度的字符串,我们可以把字符串s1分为a1,b1两个部分,s2分为a2,b2两个部分,满足((a1~a2) && (b1~b2))或者 ((a1~b2) && (a1~b2))
如此,我们找到了解决问题的思路。首先我们尝试用递归来写。
解法一(递归)
两个字符串的相似的必备条件是含有相同的字符集。简单的做法是把两个字符串的字符排序后,然后比较是否相同。
加上这个检查就可以大大的减少递归次数。
代码如下:
import java.util.*; import java.lang.*; class Program { public static void main(String []args){ System.out.println(isScramble("great","eatrg"));//true System.out.println(isScramble("abcde", "caebd"));//false } public static boolean isScramble(String s1, String s2) { //using the recursive int L1 = s1.length(); int L2 = s2.length(); if (L1 != L2) return false; if (L1 == 0) return true; char[] c1 = s1.toCharArray(); char[] c2 = s2.toCharArray(); if(L1==1)return c1[0]==c2[0]; Arrays.sort(c1); Arrays.sort(c2); for (int i = 0; i < L1; i++) { if (c1[i] != c2[i]) return false; //return true; } boolean result = false; for (int i = 1; i <L1 && !result; ++i) { String s11 = s1.substring(0, i); String s12 = s1.substring(i); String s21 = s2.substring(0, i); String s22 = s2.substring(i); result = isScramble(s11, s21) && isScramble(s12, s22); if (!result) { String s31 = s2.substring(0, L1 - i); String s32 = s2.substring(L1 - i); result = isScramble(s11, s32) && isScramble(s12, s31); } } return result; } }
解法二(动态规划)
这里使用了一个三维数组boolean result[len][len][len],其中第一维为子串的长度,第二维为s1的起始索引,第三维为s2的起始索引。
result[k][i][j]表示s1[i...i+k]是否可以由s2[j...j+k]变化得来。
import java.util.*; import java.lang.*; class Program1 { public static void main(String []args){ System.out.println(isScramble("great","eatrg")); System.out.println(isScramble("abcde", "caebd")); } public static boolean isScramble(String s1, String s2) { //using dynamic programming int L1 = s1.length(); int L2 = s2.length(); if (L1 != L2) return false; if (L1 == 0) return true; char[] c1 = s1.toCharArray(); char[] c2 = s2.toCharArray(); int len=L1; boolean[][][] result = new boolean[len][len][len]; for(int i=0;i<len;++i){ for(int j=0;j<len;++j){ result[0][i][j] = (c1[i]==c2[j]); } } for(int k=2;k<=len;++k){ for(int i=len-k;i>=0;--i){ for(int j=len-k;j>=0;--j){ boolean r = false; for(int m=1;m<k && !r;++m){ r = (result[m-1][i][j] && result[k-m-1][i+m][j+m]) || (result[m-1][i][j+k-m] && result[k-m-1][i+m][j]); } result[k-1][i][j] = r; } } } return result[len-1][0][0]; } }
参考文章:
1.http://www.blogjava.net/sandy/archive/2013/05/22/399605.html