scramble-string

题目描述：

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.

class Solution {
public:
bool isScramble(string s1, string s2) {
int len1=s1.size();
int len2=s2.size();
if (s1 == s2)
return true;
string s3=s1,s4=s2;
sort(s3.begin(),s3.end());
sort(s4.begin(),s4.end());
if(len1 != len2||s3!=s4)
return false;
for (int i = 1; i < len1; ++i){
if (isScramble(s1.substr(0, i), s2.substr(0, i))&&  isScramble(s1.substr(i), s2.substr(i)))
return true;
if (isScramble(s1.substr(0, i), s2.substr(len2 - i))&& isScramble(s1.substr(i), s2.substr(0, len2 - i)))
return true;
}
return false;
}
};

class Solution {
public:
bool isScramble(string s1, string s2) {
const int N = s1.size();
if (N != s2.size()) return false;

// f
[i][j]，表示长度为n，起点为s1[i]和
// 起点为s2[j]两个字符串是否互为scramble
bool f[N + 1]

;
fill_n(&f[0][0][0], (N + 1) * N * N, false);

for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++)
f[1][i][j] = s1[i] == s2[j];

for (int n = 1; n <= N; ++n) {
for (int i = 0; i + n <= N; ++i) {
for (int j = 0; j + n <= N; ++j) {
for (int k = 1; k < n; ++k) {
if ((f[k][i][j] && f[n - k][i + k][j + k]) ||
(f[k][i][j + n - k] && f[n - k][i + k][j])) {
f
[i][j] = true;
break;
}
}
}
}
}
return f
[0][0];
}
};