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 ifs2 is a scrambled string of s1.
一开始用递归法作,结果超时。用动态规划法通过。
递归法:
class Solution {
public:
bool isScramble(string s1, string s2) {
int l = s1.length();
int i = 0;
if (s1 == s2) return true;
if (l == 1) {
if (s1[0] == s2[0])
return true;
else
return false;
}
if (l == 2) {
if ((s1[0] == s2[0] && s1[1] == s2[1]) || (s1[0] == s2[1] && s1[1] == s2[0]))
return true;
else
return false;
}
string s11, s12, s21, s22;
for (i = 1; i <= l-1; ++i) {
s11 = s1.substr(0, i);
s12 = s1.substr(i);
s21 = s2.substr(0, i);
s22 = s2.substr(i);
if (isScramble(s11, s21) && isScramble(s12, s22))
return true;
s21 = s2.substr(l-i);
s22 = s2.substr(0, l-i);
if (isScramble(s11, s21) && isScramble(s12, s22))
return true;
}
return false;
}
};
动态规划:
class Solution {
public:
#define T(x, y, z) t[(x)*l*l + (y)*l + (z)]
bool isScramble(string s1, string s2) {
const int l = s1.length();
int *t = new int[l*l*l]();
int i = 0, j = 0, k = 0, n = 0, r = 0;
for (i = 0; i < l; ++i) {
for (j = 0; j < l; ++j) {
T(0, i, j) = s1[i] == s2[j] ? 1 : 0;
}
}
for (k = 2; k <= l; ++k) {
for (i = 0; i < l-k+1; ++i) {
for (j = 0; j < l-k+1; ++j) {
r = 0;
for (n = 1; n < k; ++n) {
if ((T(k-n-1, i, j) && T(n-1, i+k-n, j+k-n)) || (T(k-n-1, i, j+n) && T(n-1, i+k-n, j))) {
r = 1;
break;
}
}
T(k-1, i, j) = r;
}
}
}
bool ret = T(l-1, 0, 0) == 1 ? true : false;
delete[] t;
return ret;
}
};