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.
方法二: 3 dimensional dynamic programming: f(i, j, n) = || ((f(i, j, m) && f(i + m, j + m, n - m)) || f(i, j + n - m, m) && f(i + m, j, n - m)) for 1 < m < n
where f(i, j, n)
is true iff substring starts at s1[i] and substring starts at s2[j] both with length n are scrambled
bool isScramble(string s1, string s2) {
if(s1.compare(s2)==0)
return true;
vector<bool> scrambled_row(s1.length()+1, false);
vector<vector<bool>> scrambled_table(s2.length(), scrambled_row);
vector<vector<vector<bool>>> scrambled( s1.length(), scrambled_table);
for(int i = 0; i < s1.length(); i++)
for(int j = 0; j < s2.length(); j++){
scrambled[i][j][0] = true;
scrambled[i][j][1] = s1.at(i) == s2.at(j);
}
for(int i = s1.length() - 1; i >= 0 ; i--)
for(int j = s2.length() - 1; j >= 0; j--)
for(int n = 2; n <= min(s1.length() - i, s2.length() - j); n ++)
for(int m = 1; m < n; m++){
scrambled[i][j][n] = scrambled[i][j][n] || scrambled[i][j][m] && scrambled[i + m][j + m][n - m] ||
scrambled[i][j + n - m][m] && scrambled[i + m][j][n - m];
if(scrambled[i][j][n]) break;
}
return scrambled[0][0][s1.length()];
}