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.
Solution:Code:
<span style="font-size:14px;">class Solution {
public:
bool isScramble(string s1, string s2) {
int length = s1.size();
bool ***dp = new bool **[length];
for (int i = 0; i < length; i++) {
dp[i] = new bool *[length];
for (int j = 0; j < length; j++) {
dp[i][j] = new bool[length];
memset(dp[i][j], false, sizeof(bool)*length);
}
}
for (int i = length-1; i >= 0; i--)
for (int j = length-1; j >= 0; j--)
for (int k = 1; k <= length-max(i, j); k++) {
if (s1.substr(i, k) == s2.substr(j, k))
dp[i][j][k-1] = true;
else {
for (int l = 1; l <= k; l++) {
if ((dp[i][j][l-1] && dp[i+l][j+l][k-l-1]) ||
(dp[i][j+k-l][l-1] && dp[i+l][j][k-l-1])) {
dp[i][j][k-1] = true;
break;
}
}
}
}
bool result = dp[0][0][length-1];
for (int i = 0; i < length; i++) {
for (int j = 0; j < length; j++) {
delete [] dp[i][j];
}
delete [] dp[i];
}
delete [] dp;
return result;
}
};</span>