LeetCode（87）：扰乱字符串

Posted 2020-11-14 Ariel_一只猫的旅行

Hard！

题目描述：

给定一个字符串 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

解题思路：

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

这道题可以用递归Recursion或是动态规划Dynamic Programming来做，我们先来看递归的解法，参见http://blog.unieagle.net/2012/10/23/leetcode%E9%A2%98%E7%9B%AE%EF%BC%9Ascramble-string%EF%BC%8C%E4%B8%89%E7%BB%B4%E5%8A%A8%E6%80%81%E8%A7%84%E5%88%92/，简单的说，就是s1和s2是scramble的话，那么必然存在一个在s1上的长度l1，将s1分成s11和s12两段，同样有s21和s22.那么要么s11和s21是scramble的并且s12和s22是scramble的；要么s11和s22是scramble的并且s12和s21是scramble的。就拿题目中的例子 rgeat 和 great 来说，rgeat 可分成 rg 和 eat 两段， great 可分成 gr 和 eat 两段，rg 和 gr 是scrambled的， eat 和 eat 当然是scrambled。根据这点，我们可以写出代码如下。

C++解法一：

 1 // Recursion
 2 class Solution {
 3 public:
 4     bool isScramble(string s1, string s2) {
 5         if (s1.size() != s2.size()) return false;
 6         if (s1 == s2) return true;
 7         string str1 = s1, str2 = s2;
 8         sort(str1.begin(), str1.end());
 9         sort(str2.begin(), str2.end());
10         if (str1 != str2) return false;
11         for (int i = 1; i < s1.size(); ++i) {
12             string s11 = s1.substr(0, i);
13             string s12 = s1.substr(i);
14             string s21 = s2.substr(0, i);
15             string s22 = s2.substr(i);
16             if (isScramble(s11, s21) && isScramble(s12, s22)) return true;
17             s21 = s2.substr(s1.size() - i);
18             s22 = s2.substr(0, s1.size() - i);
19             if (isScramble(s11, s21) && isScramble(s12, s22)) return true;
20         }
21         return false;
22     }
23 };

这道题也可以用动态规划Dynamic Programming，根据以往的经验来说，根字符串有关的题十有八九可以用DP来做，那么难点就在于如何找出递推公式。参见https://blog.csdn.net/linhuanmars/article/details/24506703，这其实是一道三维动态规划的题目，我们提出维护量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)。

C++解法二：

 1 // DP 
 2 class Solution {
 3 public:
 4     bool isScramble(string s1, string s2) {
 5         if (s1.size() != s2.size()) return false;
 6         if (s1 == s2) return true;
 7         int n = s1.size();
 8         vector<vector<vector<bool> > > dp (n, vector<vector<bool> >(n, vector<bool>(n + 1, false)));
 9         for (int i = 0; i < n; ++i) {
10             for (int j = 0; j < n; ++j) {
11                 dp[i][j][1] = s1[i] == s2[j];
12             }
13         }
14         for (int len = 2; len <= n; ++len) {
15             for (int i = 0; i <= n - len; ++i) {
16                 for (int j = 0; j <= n - len; ++j) {
17                     for (int k = 1; k < len; ++k) {
18                         if ((dp[i][j][k] && dp[i + k][j + k][len - k]) || (dp[i + k][j][len - k] && dp[i][j + len - k][k])) {
19                             dp[i][j][len] = true;
20                         }
21                     }
22                 }
23             }
24         }
25         return dp[0][0][n];
26     }
27 };

上面的代码的实现过程如下，首先按单个字符比较，判断它们之间是否是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   √

DP的另一种写法，参考http://blog.sina.com.cn/s/blog_b9285de20101gy6n.html，思路都一样。

C++解法三：

 1 // Still DP
 2 class Solution {
 3 public:
 4     bool isScramble(string s1, string s2) {
 5         if (s1.size() != s2.size()) return false;
 6         if (s1 == s2) return true;
 7         int n = s1.size();
 8         vector<vector<vector<bool> > > dp (n, vector<vector<bool> >(n, vector<bool>(n + 1, false)));
 9         for (int i = n - 1; i >= 0; --i) {
10             for (int j = n - 1; j >= 0; --j) {
11                 for (int k = 1; k <= n - max(i, j); ++k) {
12                     if (s1.substr(i, k) == s2.substr(j, k)) {
13                         dp[i][j][k] = true;
14                     } else {
15                         for (int t = 1; t < k; ++t) {
16                             if ((dp[i][j][t] && dp[i + t][j + t][k - t]) || (dp[i][j + k - t][t] && dp[i + t][j][k - t])) {
17                                 dp[i][j][k] = true;
18                                 break;
19                             }
20                         }
21                     }
22                 }
23             }
24         }
25         return dp[0][0][n];
26     }
27 };

下面这种解法和第一个解法思路相同，只不过没有用排序算法，而是采用了类似于求异构词的方法，用一个数组来保存每个字母出现的次数，后面判断Scramble字符串的方法和之前的没有区别。

C++解法四：

 1 class Solution {
 2 public:
 3     bool isScramble(string s1, string s2) {
 4         if (s1 == s2) return true;
 5         if (s1.size() != s2.size()) return false;
 6         int n = s1.size(), m[26] = {0};
 7         for (int i = 0; i < n; ++i) {
 8             ++m[s1[i] - \'a\'];
 9             --m[s2[i] - \'a\'];
10         }
11         for (int i = 0; i < 26; ++i) {
12             if (m[i] != 0) return false;
13         }
14         for (int i = 1; i < n; ++i) {
15             if ((isScramble(s1.substr(0, i), s2.substr(0, i)) && isScramble(s1.substr(i), s2.substr(i))) || (isScramble(s1.substr(0, i), s2.substr(n - i)) && isScramble(s1.substr(i), s2.substr(0, n - i)))) {
16                 return true;
17             }
18         }
19         return false;
20     }
21 };

下面这种解法实际上是解法二的递归形式，我们用了memo数组来减少了大量的运算，注意这里的memo数组一定要有三种状态，初始化为-1，区域内为scramble是1，不是scramble是0，这样就避免了已经算过了某个区间，但由于不是scramble，从而又进行一次计算，从而会TLE，思路参见http://www.cnblogs.com/bambu/

C++解法五：

 1 class Solution {
 2 public:
 3     bool isScramble(string s1, string s2) {
 4         if (s1 == s2) return true;
 5         if (s1.size() != s2.size()) return false;
 6         int n = s1.size();
 7         vector<vector<vector<int>>> memo(n, vector<vector<int>>(n, vector<int>(n + 1, -1)));
 8         return helper(s1, s2, 0, 0, n, memo);
 9     }
10     bool helper(string& s1, string& s2, int idx1, int idx2, int len, vector<vector<vector<int>>>& memo) {
11         if (len == 0) return true;
12         if (len == 1) memo[idx1][idx2][len] = s1[idx1] == s2[idx2];
13         if (memo[idx1][idx2][len] != -1) return memo[idx1][idx2][len];
14         for (int k = 1; k < len; ++k) {
15             if ((helper(s1, s2, idx1, idx2, k, memo) && helper(s1, s2, idx1 + k, idx2 + k, len - k, memo)) || (helper(s1, s2, idx1, idx2 + len - k, k, memo) && helper(s1, s2, idx1 + k, idx2, len - k, memo))) {
16                 return memo[idx1][idx2][len] = 1;
17             }
18         }
19         return memo[idx1][idx2][len] = 0;
20     }
21 };