[Leetcode] 87. Scramble String 解题报告

题目：

Given a string s1, we may represent it as a binary tree by partitioning it to two non-empty substrings recursively.

Below is one possible representation of s1 = "great":

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

To scramble the string, we may choose any non-leaf node and swap its two children.

For example, if we choose the node "gr" and swap its two children, it produces a scrambled string "rgeat".

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

We say that "rgeat" is a scrambled string of "great".

Similarly, if we continue to swap the children of nodes "eat" and "at", it produces a scrambled string "rgtae".

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

We say that "rgtae" is a scrambled string of "great".

Given two strings s1 and s2 of the same length, determine if s2 is a scrambled string of s1.

思路：

1、递归法：如果s1是s2的scramble string，那么要么s1和s2相等，要么在从s1变换到s2的过程中的最后一步，必然是从s1的中间某个部分切开，形成s11和s12，并且s11和s12都分别可以scramble到s2的前（后）部分或者后（前）部分。所以我们可以递归地求解这一问题。为了加快速度，可以进行适当剪枝：1）两者长度不等；2）两者所含有的可重复字母集合不同。二递归基则是字符串长度为1的情况。

2、动态规划法：定义dp[i][j][k]表示s1.substr(i, k)和s2.substr(j, k)是否是scramble string，则递推方程很容易写出来（具体递推方程可见代码实现）。该动态规划方法的时间复杂度是O(n^4)，空间复杂度是O(n^3)。感觉也不是很好，不过所有测试用例倒是都可以通过。

代码：

1、递归法：

class Solution {
public:
    bool isScramble(string s1, string s2) {
        if (s1.length() != s2.length()) {
            return false;
        }
        if (s1 == s2) {
            return true;
        }
        if (s1.length() == 1) {
            return false;
        }
        unordered_map<char, int> hash;
        int len1 = s1.length(), len2 = s2.length();
        for (int i = 0; i < len1; ++i) {
            hash[s1[i]]++;
        }
        for (int i = 0; i < len2; ++i) {
            hash[s2[i]]--;
        }
        for (auto it = hash.begin(); it != hash.end(); ++it) {
            if (it->second != 0) {
                return false;
            }
        }
        for (int i = 1; i < len1; ++i) {
            bool ret = isScramble(s1.substr(0, i), s2.substr(0, i)) &&
                       isScramble(s1.substr(i, len1 - i), s2.substr(i, len2 - i));
            ret = ret || isScramble(s1.substr(0, i), s2.substr(len2 - i, i)) &&
                         isScramble(s1.substr(i, len1 - i), s2.substr(0, len2 - i));
            if (ret) {
                return true;
            }
        }
        return false;
    }
};

2、动态规划法：

class Solution {
public:
    bool isScramble(string s1, string s2) {
        if (s1.length() != s2.length()) {
            return false;
        }
        int length = s1.length();
        // dp[i][j][k] means whether s1.substr(i, k) is scramble of s2.substr(j, k) 
        vector<vector<vector<bool>>> dp(length, vector<vector<bool>>(length, vector<bool>(length + 1, false)));
        for (int k = 1; k <= length; ++k) {
            for (int i = 0; i + k - 1 < length; ++i) {
                for (int j= 0; j + k - 1 < length; ++j) {
                    if (k == 1) {
                        dp[i][j][k] = (s1[i] == s2[j]);
                        continue;
                    }
                    else {
                        for (int p = 1; p < k; ++p) {
                            int length1 = p, length2 = k - p;
                            if (dp[i][j][length1] && dp[i + length1][j + length1][length2]) {
                                dp[i][j][k] = true;
                                break;
                            }
                            if (dp[i][j + length2][length1] && dp[i + length1][j][length2]) {
                                dp[i][j][k] = true;
                                break;
                            }
                        }
                    }
                }
            }
        }
        return dp[0][0][length];
    }
};