NO.87 扰乱字符串

给定一个字符串 s1，我们可以把它递归地分割成两个非空子字符串，从而将其表示为二叉树。

下图是字符串 s1 = "great" 的一种可能的表示形式。

    great
   /    \
  gr    eat
 / \    /  \
g   r  e   at
           / \
          a   t

在扰乱这个字符串的过程中，我们可以挑选任何一个非叶节点，然后交换它的两个子节点。

例如，如果我们挑选非叶节点 "gr" ，交换它的两个子节点，将会产生扰乱字符串 "rgeat" 。

    rgeat
   /    \
  rg    eat
 / \    /  \
r   g  e   at
           / \
          a   t

我们将 "rgeat” 称作 "great" 的一个扰乱字符串。

同样地，如果我们继续将其节点 "eat" 和 "at" 进行交换，将会产生另一个新的扰乱字符串 "rgtae" 。

    rgtae
   /    \
  rg    tae
 / \    /  \
r   g  ta  e
       / \
      t   a

我们将 "rgtae” 称作 "great" 的一个扰乱字符串。

给出两个长度相等的字符串 s1 和 s2，判断 s2 是否是 s1 的扰乱字符串。

示例 1:

输入: s1 = "great", s2 = "rgeat"
输出: true

示例 2:

输入: s1 = "abcde", s2 = "caebd"
输出: false

class Solution {
private:
    bool dfs(string& s1, string& s2, int start_s1, int start_s2, int search_len) {
        //判断串包含的字母是否一致
        string substr1 = s1.substr(start_s1, search_len);
        string substr2 = s2.substr(start_s2, search_len);
        sort(substr1.begin(), substr1.end());
        sort(substr2.begin(), substr2.end());
        if(substr1 != substr2) return false;
        //1,2为遍历终止条件
        if(search_len <= 2) return true;
        //从长度1----search_len-1 裁剪子串
        //先比较正序，再比较扰乱
        for(int j = 1; j < search_len; j++){
            //
            //判断s1拆分成的两个子串与s2拆分的两个子串是不是扰乱字符串
            if(dfs(s1,s2,start_s1,start_s2,j)&&dfs(s1,s2,start_s1+j,start_s2+j,search_len-j))return true;
            //判断s1拆分成的两个子串扰乱后与s2拆分的两个子串是不是扰乱字符串
            else if(dfs(s1,s2,start_s1,start_s2+search_len-j,j)&&dfs(s1,s2,start_s1+j,start_s2,search_len-j))return true;
        }
        return false;
    }
public:
    bool isScramble(string s1, string s2) {
        if(s1.empty() && s2.empty()) return true;
        if(s1.size() != s2.size()) return false;
        return dfs(s1,s2,0,0,s1.size());
    }
};

执行用时 : 12 ms, 在Scramble String的C++提交中击败了91.72% 的用户

内存消耗 : 9.7 MB, 在Scramble String的C++提交中击败了80.70% 的用户