bool isScramble(string s1, string s2) {
int l1 = s1.length();
int l2 = s2.length();
if (l1 != l2)
return false;
if (l1 == 0)
return true;
if (l1 == 1)
return s1 == s2;
string s11 = s1;
string s22 = s2;
sort(s11.begin(), s11.end());
sort(s22.begin(), s22.end());
if (s11 != s22)
return false;
for (int i=1; i < l1; i++) {
string s11 = s1.substr(0, i);
string s12 = s1.substr(i);
string s21 = s2.substr(0, i);
string s22 = s2.substr(i);
if (isScramble(s11, s21) && isScramble(s12, s22))
return true;
string s23 = s2.substr(0, l1-i);
string s24 = s2.substr(l1-i);
if (isScramble(s11, s24) && isScramble(s12, s23))
return true;
}
return false;
}
bool isScramble(string s1, string s2) {
int len1=s1.length();
int len2=s2.length();
if (len1!=len2) return false;
if (len1==1) return s1==s2;
string ss1=s1;
string ss2=s2;
sort(ss1.begin(), ss1.end());
sort(ss2.begin(), ss2.end());
if (ss1!=ss2) return false;
bool ret=false;
for (int i=1;i<len1&&ret==false;i++)
{
string s11=s1.substr(0,i);
string s12=s1.substr(i,len1-i);
string s21=s2.substr(0,i);
string s22=s2.substr(i,len1-i);
ret=isScramble(s11,s21)&&isScramble(s12,s22);
if (ret==false)
{
s21=s2.substr(0,len1-i);
s22=s2.substr(len1-i,i);
ret=isScramble(s11,s22)&&isScramble(s12,s21);
}
}
return ret;
}
bool isScramble(string s1, string s2) {
if (s1.length() == 0 && s2.length() == 0) {
return true;
}
if (s1.length() != s2.length()) {
return false;
}
if (s1.length() == 1) {
return s1[0] == s2[0];
}
auto sorted_s1 = s1;
auto sorted_s2 = s2;
sort(sorted_s1.begin(), sorted_s1.end());
sort(sorted_s2.begin(), sorted_s2.end());
if (sorted_s1 != sorted_s2) {
return false;
}
int length = s1.length();
for (int i=1; i<length; ++i) {
if ((isScramble(s1.substr(0, i), s2.substr(length-i, i))
&& isScramble(s1.substr(i), s2.substr(0, length-i)))
|| (isScramble(s1.substr(0, i), s2.substr(0, i))
&& isScramble(s1.substr(i), s2.substr(i)))) {
return true;
}
}
return false;
}
bool isScramble(string &s1, string &s2, int p1, int l1, int p2, int l2) {
if (l1 != l2) {
return false;
}
// check chars
vector<int> chars(26, 0);
for (int i = p1; i < p1+l1; i++) {
chars[s1[i]-'a']++;
}
for (int i = p2; i < p2+l2; i++) {
if (chars[s2[i]-'a']-- == 0) {
return false;
}
}
if (l1 == 1) {
return true;
}
for (int i = 1; i < l1; i++) {
bool res = (isScramble(s1, s2, p1, i, p2, i) &&
isScramble(s1, s2, p1+i, l1-i, p2+i, l2-i)) ||
(isScramble(s1, s2, p1, i, p2+l2-i, i) &&
isScramble(s1, s2, p1+i, l1-i, p2, l2-i));
if (res) {
return true;
}
}
return false;
}
bool isScramble(string s1, string s2) {
int m = s1.length();
if(s1.compare(s2) == 0)
return true;
string temp1 = s1, temp2 = s2;
sort(temp1.begin(), temp1.end());
sort(temp2.begin(), temp2.end());
if(temp1.compare(temp2) != 0)
return false;
for(int len = 1; len < m; len++)
{
string strl1 = s1.substr(0, len);
string strr1 = s1.substr(len, m - len);
string strl2 = s2.substr(0, len);
string strr2 = s2.substr(len, m - len);
if(isScramble(strl1, strl2) && isScramble(strr1, strr2))
return true;
string strl22 = s2.substr(0, m - len);
string strr22 = s2.substr(m - len, len);
if(isScramble(strl1, strr22) && isScramble(strr1, strl22))
return true;
}
return false;
}
bool isScramble(string::iterator begin1, string::iterator end1, string::iterator begin2, string::iterator end2) {
if (string(begin1, end1) == string(begin2, end2))
return true;
unordered_map<char, int> recs;
for (string::size_type i = 0; begin1 + i != end1; i++) {
recs[*(begin1+i)]++;
recs[*(begin2+i)]--;
}
for (auto iter = recs.begin(); iter != recs.end(); iter++) {
if (iter->second != 0)
return false;
}
for (string::size_type i = 1; begin1 + i != end1; i++) {
if (isScramble(begin1, begin1+i, begin2, begin2+i) && isScramble(begin1+i, end1, begin2+i, end2))
return true;
if (isScramble(begin1, begin1+i, end2-i, end2) && isScramble(begin1+i, end1, begin2, end2-i))
return true;
}
return false;
}
// DFS + Pruning:
bool isScramble(string s1, string s2) {
if (s1.length() != s2.length())
return false;
if (s1 == s2)
return true;
// pruning with a char set
vector<int> m_chars (26, 0);
for (int i = 0; i < s1.length(); i++) {
m_chars[s1[i] - 'a'] += 1;
m_chars[s2[i] - 'a'] -= 1;
}
for (int i = 0; i < 26; i++){
if (m_chars[i] != 0)
return false;
}
for (int i = 1; i <= s1.length() - 1; i++) {
string s11 = s1.substr(0, i);
string s12 = s1.substr(i);
string s21 = s2.substr(0, i);
string s22 = s2.substr(i);
string s31 = s2.substr(s2.length() - i);
string s32 = s2.substr(0, s2.length() - i);
if ((isScramble(s11, s21) && isScramble(s12, s22) )||
(isScramble(s11, s31) && isScramble(s12, s32) ))
return true;
}
return false;
}
/**
* 必然存在一个切割，使得s1与s2分成两段，且这两部分也都是scramble。
* 穷举，剪枝可过。
*/
bool isScramble(string s1, string s2) {
if (s1.size() != s2.size())
return false;
if (s1 == s2)
return true;
if (s1.size() <= 0)
return false;
//排序剪枝
string s1Sorted = s1;
string s2Sorted = s2;
sort(s1Sorted.begin(), s1Sorted.end());
sort(s2Sorted.begin(), s2Sorted.end());
if(s1Sorted != s2Sorted)
return false;
//递归尝试所有切割方法
//s1: [0, split - 1], [split, len - 1]
//s2: [0, split - 1], [split, len - 1] or [0, len - split - 1], [len - split, len - 1]
int len = s1.size();
for(int split = 1; split <= len - 1; split++){
string s1Left = s1.substr(0, split);
string s1Right = s1.substr(split);
string s2Left = s2.substr(0, split);
string s2Right = s2.substr(split);
string s2RevLeft = s2.substr(len - split);
string s2RevRight = s2.substr(0, len - split);
//bool seq = isScramble(s1Left, s2Left) && isScramble(s2Right, s2Right);
//bool rev = isScramble(s1Left, s2RevLeft) && isScramble(s1Right, s2RevRight);
if( (isScramble(s1Left, s2Left) && isScramble(s1Right, s2Right)) ||
(isScramble(s1Left, s2RevLeft) && isScramble(s1Right, s2RevRight)) )
return true;
}
return false;
}
bool isScramble(string s1, string s2) {
if(s1 == s2) {
return true;
}
if(s1.length() != s2.length()) {
return false;
}
int len = s1.length();
vector<int> a(26, 0)
for(int i = 0; i < len; i++) {
a[s1[i]-'a']++;
a[s2[i]-'a']--;
}
for(int i = 0; i < 26; i++) {
if(a[i] != 0) {
return false;
}
}
for(int i = 1; i < len; 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(l-i)) && isScramble(s1.substr(i), s2.substr(0, i))) {
return true;
}
}
return false;
}
bool isScramble(const string &s1, int s1b, const string &s2, int s2b, int len,
vector<vector<vector<int>>> &memo) {
auto &m = memo[s1b][s2b][len - 1];
if (m != -1)
return m;
if (len == 1) {
m = (s1[s1b] == s2[s2b]);
} else {
m = 0;
for (int split = 1; split < len; ++split) {
if (isScramble(s1, s1b, s2, s2b, split, memo) &&
isScramble(s1, s1b + split, s2, s2b + split, len - split, memo)) {
m = 1;
break;
}
if (isScramble(s1, s1b, s2, s2b + len - split, split, memo) &&
isScramble(s1, s1b + split, s2, s2b, len - split, memo)) {
m = 1;
break;
}
}
}
return m;
}
bool isScramble(string s1, string s2) {
if(s1.size() != s2.size() || s1.size() == 0 || s2.size() == 0){
return false;
}
if(s1 == s2){
return true;
}
//to fast the counting speed
string ss1 = s1;
string ss2 = s2;
sort(ss1.begin(), ss1.end());
sort(ss2.begin(), ss2.end());
if (ss1 != ss2 ) {
return false;
}
for(int i=1; i<s1.size(); i++){
if(isScramble(s1.substr(0,i), s2.substr(0,i)) && isScramble(s1.substr(i, s1.size()-i), s2.substr(i, s2.size()-1))){
return true;
}
if(isScramble(s1.substr(0,i), s2.substr(s2.size()-i, i)) && isScramble(s1.substr(i,s1.size()-i),s2.substr(0,s2.size()-i))){
return true;
}
}
return false;
}
bool isScramble(string s1, string s2) {
if (!isAnagram(s1, s2)) return false;
auto problem = make_pair(s1, s2);
if (s1 == s2) return true;
for (int i = 1; i < s1.size(); i++){
if (isScramble(s1.substr(0, i), s2.substr(s2.size() - i))
&& isScramble(s1.substr(i), s2.substr(0, s2.size() - i))) return true;
if (isScramble(s1.substr(0, i), s2.substr(0, i))
&& isScramble(s1.substr(i), s2.substr(i))) return true;
}
return false;
}
bool isScramble(string s1, string s2) {
if (s1 == s2) return true;
if (s1.size() != s2.size()) return false;
int n = s1.size();
for (int i = 1; i < n; ++i) {
if (isScramble(s1.substr(0, i), s2.substr(0, i)) &&
isScramble(s1.substr(i, n - i), s2.substr(i, n - i)))
return true;
if (isScramble(s1.substr(n - i, i), s2.substr(0, i)) &&
isScramble(s1.substr(0, n - i), s2.substr(i, n - i)))
return true;
}
return false;
}
bool isScramble(string s1, string s2) {
if (!isAnagram(s1, s2)) return false;
auto key = make_pair(s1, s2);
if (Cache.count(key)) return Cache[key];
auto &res = Cache[key];
if (s1 == s2) return true;
for (int i = 1; i < s1.size(); i++){
if (isScramble(s1.substr(0, i), s2.substr(s2.size() - i))
&& isScramble(s1.substr(i), s2.substr(0, s2.size() - i))) return res = true;
if (isScramble(s1.substr(0, i), s2.substr(0, i))
&& isScramble(s1.substr(i), s2.substr(i))) return res = true;
}
return res = false;
}
bool isScramble(string s1, string s2) {
int l1 = s1.length(), l2 = s2.length();
if(l1!=l2) return false;
if(l1 == 1) return s1[0] == s2[0];
string tmp_s1 = s1, tmp_s2 = s2;
sort(tmp_s1.begin(), tmp_s1.end());
sort(tmp_s2.begin(), tmp_s2.end());
for(int i = 0; i<l1; ++i)
if(tmp_s1[i] != tmp_s2[i]) return false;
bool result = false;
for(int i=1; i<l1 && result == false; ++i)
{
string s1_left = s1.substr(0,i);
string s1_right = s1.substr(i);
string s2_left = s2.substr(0,i);
string s2_right = s2.substr(i);
string s3_left = s2.substr(0, l1-i);
string s3_right = s2.substr(l1-i);
result = (isScramble(s1_left, s2_left) && isScramble(s1_right, s2_right))
||(isScramble(s1_left, s2_right) && isScramble(s1_right, s2_left))
|| (isScramble(s1_left, s3_left) && isScramble(s1_right, s3_right))
||(isScramble(s1_left, s3_right) && isScramble(s1_right, s3_left));
}
return result;
}
bool isScramble(iter s1_first, iter s1_last, iter s2_first, iter s2_last){
int sz = s1_last - s1_first;
if (sz == 1 ){
return *s1_first == *s2_first;
}
for (int i = 1; i < sz; ++i){
if ((isScramble(s1_first, s1_first+i, s2_first, s2_first +i) && isScramble(s1_first+i, s1_last, s2_first + i, s2_last)) || (isScramble(s1_first, s1_first+i, s2_last -i, s2_last) && isScramble(s1_first+i, s1_last, s2_first, s2_last - i))){
return true;
}
}
return false;
}
/**
* @param s1 A string
* @param s2 Another string
* @return whether s2 is a scrambled string of s1
*/
bool isScramble(string& s1, string& s2) {
if (s1.size() != s2.size()) return false;
if (s1 == s2) return true;
for (int i = 1; i < s1.size(); ++i) {
string s11 = s1.substr(0,i);
string s12 = s1.substr(i);
string s21 = s2.substr(0,i);
string s22 = s2.substr(i);
string ss21 = s2.substr(0, s2.size()-i);
string ss22 = s2.substr(s2.size()-i);
if ((isScramble(s11, s21) && isScramble(s12, s22))
||(isScramble(s11, ss22) && isScramble(s12, ss21)))
return true;
}
return false;
}
bool isScramble(string s1, string s2) {
if(s1.size()!=s2.size()) return false ;
if(s1.empty()) return true;
if(s1==s2) return true;
string t1(s1) ;
string t2(s2) ;
sort(t1.begin(),t1.end());
sort(t2.begin(),t2.end());
if(t1!=t2) return false ;
for(int i = 1 ; i<s1.size();i++){
if(isScramble(s1.substr(0,i),s2.substr(0,i)) && isScramble(s1.substr(i,s1.size()-i),s2.substr(i,s2.size()-i)))
return true;
if(isScramble(s1.substr(0,i),s2.substr(s2.size()-i,i)) && isScramble(s1.substr(i,s1.size()-i),s2.substr(0,s1.size()-i)))
return true;
}
return false;
}
bool isScramble(string s1, string s2) {
if (s1.size() != s2.size()){
return false;
}
return isScramble(s1.begin(), s1.end(), s2.begin(), s2.end());
}
int main(int argc, char **argv)
{
if (argc != 3) {
fprintf(stderr, "Usage: ./test s1 s2\n");
exit(-1);
}
printf("%s\n", isScramble(argv[1], argv[2]) ? "true" : "false");
return 0;
}
bool isScramble(string s1, string s2) {
if(s1 == s2) return true;
int count[26] = {0};
int len = s1.size();
for(int i=0;i<s1.size();i++){
count[s1[i]-'a'] ++;//attention - 'a'
count[s2[i]-'a'] --;
}
for(int i=0;i<26;i++){
if(count[i] != 0) return false;
}
for(int i=1;i<len;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(len-i)) && isScramble(s1.substr(i),s2.substr(0,len-i))) return true;
}
return false;
}
bool isScramble(string s1, string s2) {
// Start typing your C/C++ solution below
// DO NOT write int main() function
if (s1.length() == 0) {
return true;
}
return isScramble(s1, s2, 0, s1.length(), 0, s2.length());
}
bool isScramble(string s1, string s2) {
int sz = s1.size();
if (sz != s2.size())
return false;
vector<vector<vector<int>>> memo(
sz, vector<vector<int>>(sz, vector<int>(sz, -1)));
return isScramble(s1, 0, s2, 0, sz, memo);
}
bool isScramble(string s1, string s2) {
if(s1 == s2)
return true;
unordered_map<char, int> m;
for(char c : s1)
m[c]++;
for(char c : s2)
m[c]--;
for(auto x : m)
if(x.second != 0)
return false;
for(int i = 1; i < s1.size(); 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(s1.size() - i)) && isScramble(s1.substr(i), s2.substr(0, s1.size() - i)))
return true;
}
return false;
}
bool isScramble(string s1, string s2) {
if (s1 == s2)return true;
int size = s1.size();
int value1 = 0, value2 = 0;
for (int i = 0; i < size; ++i) {
value1 += (s1[i] - 'a');
value2 += (s2[i] - 'a');
}
if (value1 != value2)
return false;
for (int i = 1; i < size; 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(size - i)) && isScramble(s1.substr(i), s2.substr(0, size - i)))
return true;
}
return false;
}
bool isScramble(int sa, int ea, int sb, int eb) {
int M = ea - sa, N = eb - sb;
if (M != N) return false;
int key = getHash(sa, ea, sb, eb);
if (m.find(key) != m.end()) return m[key];
bool ans = false;
if (!A.compare(sa, ea - sa, B, sb, eb - sb)) ans = true;
else if (!isAnagram(sa, ea, sb, eb)) ans = false;
else {
for (int len = 1; len < M; ++len) {
if ((isScramble(sa, sa + len, sb, sb + len) && isScramble(sa + len, ea, sb + len, eb))
|| (isScramble(sa, sa + len, eb - len, eb) && isScramble(sa + len, ea, sb, eb - len))) {
ans = true;
break;
}
}
}
return m[key] = ans;
}
bool isScramble(string s1, string s2) {
if (0 == s1.compare(s2)) { return true; }
string copy1 = s1;
string copy2 = s2;
sort(copy1.begin(), copy1.end());
sort(copy2.begin(), copy2.end());
if (0 != copy1.compare(copy2)) { return false; }
for (int i = 1; i < s1.size(); i++) {
if (isScramble(s1.substr(0, i), s2.substr(0, i)) &&
isScramble(s1.substr(i, s1.size() - i), s2.substr(i, s2.size() - i))) {
return true;
}
if (isScramble(s1.substr(0, i), s2.substr(s2.size() - i, i)) &&
isScramble(s2.substr(0, s2.size() - i), s1.substr(i, s1.size() - i))) {
return true;
}
}
return false;
}
bool isScramble(string s1, string s2) {
if (s1.size() != s2.size()) {
return false;
}
if (s1 == s2) {
return true;
}
for (int i = 1; i < (int)s1.size(); ++i) {
string s1_l = s1.substr(0, i);
string s2_l = s2.substr(0, i);
std::sort(s1_l.begin(), s1_l.end());
std::sort(s2_l.begin(), s2_l.end());
if (s1_l == s2_l) {
if (
isScramble(s1.substr(0, i), s2.substr(0, i))
&& isScramble(s1.substr(i), s2.substr(i))
) {
return true;
}
}
string s2_r = s2.substr(s2.size() - i, i);
std::sort(s2_r.begin(), s2_r.end());
if (s1_l == s2_r) {
if (
isScramble(s1.substr(0, i), s2.substr(s2.size() - i, i))
&& isScramble(s1.substr(i), s2.substr(0, s2.size() - i))
) {
return true;
}
}
}
return false;
}
bool isScramble(string s1, string s2) {
if (s1.empty() && s2.empty())
return true;
if (s1.empty() || s2.empty())
return false;
if (s1.length() != s2.length())
return false;
if (s1 == s2)
return true;
return isScramble(s1.begin(), s1.end(), s2.begin(), s2.end());
}
bool isScramble(Iterator first1, Iterator last1, Iterator first2) {
auto length = distance(first1, last1);
auto last2 = next(first2, length);
if (length == 1) return *first1 == *first2;
// 剪枝，提前返回
int A[26]; // 每个字符的计数器
fill(A, A + 26, 0);
for(int i = 0; i < length; i++) A[*(first1+i)-'a']++;
for(int i = 0; i < length; i++) A[*(first2+i)-'a']--;
for(int i = 0; i < 26; i++) if (A[i] != 0) return false;
for (int i = 1; i < length; ++i)
if ((isScramble(first1, first1 + i, first2)
&& isScramble(first1 + i, last1, first2 + i))
|| (isScramble(first1, first1 + i, last2 - i)
&& isScramble(first1 + i, last1, first2)))
return true;
return false;
}
