87. 扰乱字符串

87. 扰乱字符串

简单的说，就是s1和s2是scramble的话，那么必然存在一个在s1上的长度l1，将s1分成s11和s12两段，同样有s21和s22.那么要么s11和s21是scramble的并且s12和s22是scramble的；要么s11和s22是scramble的并且s12和s21是scramble的。

hard.
4ms 暴力递归ac。

class Solution {
 public:
	 bool isScramble(string s1, string s2) {
		 if (s1.size() != s2.size())return false;
		 if (s1 == s2)return true;
		 string str1 = s1; string 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++)
		 {
			 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;
			 s21 = s2.substr(s2.size() - i);
			 s22 = s2.substr(0, s2.size() - i);
			 if (isScramble(s11, s21) && isScramble(s12, s22))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的所有情况我们都在前面求解过了（也就是长度是最外层循环）。
上面说的是劈一刀的情况，对于s1[i…i+len-1]我们有len-1种劈法，在这些劈法中只要有一种成立，那么两个串就是scramble的。
总结起来递推式是res[i][j][len] = || (res[i][j][k]&&res[i+k][j+k][len-k] || res[i][j+len-k][k]&&res[i+k][j][len-k])对于所有1<=k<len，也就是对于所有len-1种劈法的结果求或运算。因为信息都是计算过的，对于每种劈法只需要常量操作即可完成，因此求解递推式是需要O(len)（因为len-1种劈法）。
如此总时间复杂度因为是三维动态规划，需要三层循环，加上每一步需要线行时间求解递推式，所以是$O(n^4)$。虽然已经比较高了，但是至少不是指数量级的，动态规划还是有很大有事的，空间复杂度是$O(n^3)$。代码如下：

// DP 
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<bool> > > dp (n, vector<vector<bool> >(n, vector<bool>(n + 1, false)));
        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];
    }
};

引自[3]: 上面的代码的实现过程如下，首先按单个字符比较，判断它们之间是否是scrambled的。在更新第二个表中第一个值(gr和rg是否为scrambled的)时，比较了第一个表中的两种构成，一种是 g与r, r与g，另一种是 g与g, r与r，其中后者是真，只要其中一个为真，则将该值赋真。其实这个原理和之前递归的原理很像，在判断某两个字符串是否为scrambled时，比较它们所有可能的拆分方法的子字符串是否是scrambled的，只要有一个种拆分方法为真，则比较的两个字符串一定是scrambled的。比较 rge 和 gre 的实现过程如下所示：

     r    g    e
g    x    √    x
r    √    x    x
e    x    x    √


      rg    ge
gr    √    x
re    x    x


     rge
gre   √

引自：[2]这是LeetCode中最难的动态规划的题目了，要进行一次三维动态规划，对于维护量的含义也比较讲究。有朋友会讨论这个维护量是怎么提出来的，我自己[2]也没什么绝对的方法，还是熟能生巧，靠“感觉”，做的题目多了就自然来了，这个做高中数学题有点类似哈，辅助线是靠“灵感”的哈。

[1]http://blog.unieagle.net/2012/10/23/leetcode题目：scramble-string，三维动态规划/
[2]https://blog.csdn.net/linhuanmars/article/details/24506703
[3]https://www.cnblogs.com/grandyang/p/4318500.html