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.
c++:class Solution {
public:
bool isScramble(string s1, string s2) {
int len1 = s1.length();
int len2 = s2.length();
if(len1 != len2) {
return false;
}
int len = len1;
bool f[len][len][len];
int i,j,k;
for(i = 0;i < len;i ++) {
for(j = 0;j < len;j ++) {
for(k = 0;k < len;k ++) {
f[i][j][k] = false;
}
}
}
for(i = 0;i < len;i ++) {
for(j = 0;j < len;j ++) {
if(s1[i] == s2[j]) {
f[0][i][j] = true;
}
}
}
int l;
for(k = 1;k < len;k ++) {
for(i = 0;i < len-k;i ++) {
for(j = 0;j < len-k;j ++) {
for(l = 0;l < k;l ++) {
if((f[l][i][j] && f[k-l-1][i+l+1][j+l+1]) || (f[l][i+k-l][j] && f[k-l-1][i][j+l+1])) {
f[k][i][j] = true;
break;
}
}
}
}
}
return f[len-1][0][0];
}
};