87. Scramble String

这道题定义了一种爬行字符串，就是说假如把一个字符串当做一个二叉树的根，然后它的非空子字符串是它的子节点，然后交换某个子字符串的两个子节点，重新爬行回去形成一个新的字符串，这个新字符串和原来的字符串互为爬行字符串。还是参考了大神的博客。。。

递归。

题意在于判断一个字符串是否为另一个字符串“乱序”得到，这种乱序采用的方式是将一个字符串从某个位置“割开”，形成两个子串，然后对两个子串进行同样的“割开”操作，直到到达叶子节点，无法再分割。所以用递归。每一个位置都有可能是分割点，遍历每一个位置，看由这个位置分成的两个字符串能否继续分割达到要求。那什么时候两个字符串互为爬行字符串呢？如果string1的左子树等于string2的左子树，string1的右子树等于string2的右子树的时候，是互为爬行字符串的；当string1的左子树等于string2的右子树，string1的右子树等于string2的左子树，这时候也是互为爬行字符串。

class Solution {
public:
    bool isScramble(string s1, string s2) {
        if (s1.size() != s2.size()) return false;  
        if (s1 == s2) return true;  
        string str1 = s1, str2 = s2;
        sort(str1.begin(), str1.end());  
        sort(str2.begin(), str2.end());  
        if (str1 != str2) 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(s2.size() - i)) && isScramble(s1.substr(i), s2.substr(0, s2.size() - i))) return true;  
        }  
        return false; 
    }
};

动态规划：

这其实是一道三维动态规划的题目，我们提出维护量res[i][j][n]，其中i是s1的起始字符，j是s2的起始字符，而n是当前的字符串长度，res[i][j][len]表示的是以i和j分别为s1和s2起点的长度为len的字符串是不是互为scramble。
有了维护量我们接下来看看递推式，也就是怎么根据历史信息来得到res[i][j][len]。判断这个是不是满足，其实我们首先是把当前s1[i...i+len-1]字符串劈一刀分成两部分，然后分两种情况：第一种是左边和s2[j...j+len-1]左边部分是不是scramble，以及右边和s2[j...j+len-1]右边部分是不是scramble；第二种情况是左边和s2[j...j+len-1]右边部分是不是scramble，以及右边和s2[j...j+len-1]左边部分是不是scramble。如果以上两种情况有一种成立，说明s1[i...i+len-1]和s2[j...j+len-1]是scramble的。而对于判断这些左右部分是不是scramble我们是有历史信息的，因为长度小于n的所有情况我们都在前面求解过了（也就是长度是最外层循环）。

class Solution {
public:
    bool isScramble(string s1, string s2) {
        if(s1.size() != s2.size())  return false;
        if(s1 == s2)    return true;
        int n = s1.size();
        vector<vector<vector<int>>> dp(n, vector<vector<int>>(n, vector<int>(n+1, 0)));
        for(int i = 0; i < n; ++i){
            for(int j = 0; j < n; ++j){
                dp[i][j][1] = (s1[i] == s2[j]);
            }
        }
        for(int len = 2; len <= n; ++len){
            for(int i = 0; i <= n - len; ++i){
                for(int j = 0; j <= n - len; ++j){
                    for(int k = 1; k < len; ++k){
                        if((dp[i][j][k] && dp[i+k][j+k][len-k]) || (dp[i+k][j][len-k] && dp[i][j+len-k][k])){
                            dp[i][j][len] = true;
                        }
                    }
                }
                
            }
        }
        return dp[0][0][n];
    }
};