编程题——攀爬字符串

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

由于二叉树是递归的建立的，那么我们就可以尝试从递归的角度来解决这个问题。对于两个字符串树treeA和treeB,分别记其左右子树为treeA(B)_left,treeA(B)_right,那么可以得到如下关系： 
isScramble(treeA, treeB) = isScramble(treeA_left, treeB_left) && isScramble(treeA_right, treeB_right) || 
isScramble(treeA_left, treeB_right) && isScramble(treeA_right, treeB_left)。 
就是把字符串s1分割成s11和s12，把字符串s2在同样位置分割成s21和s22，如果s11与s21,s12与s22都为攀爬字符串或者s11与s22,s12与s21为攀爬字符串，那么字符串s1和s2就同为攀爬字符串。

class Solution {
public:
    /*
     * @param s1: A string
     * @param s2: Another string
     * @return: whether s2 is a scrambled string of s1
     */
    bool isScramble(string s1, string s2) {
        if (s1 == s2) return true;
        string tmp1 = s1, tmp2 = s2;
        sort(tmp1.begin(), tmp1.end());
        sort(tmp2.begin(), tmp2.end());
        if (tmp1 != tmp2) return false;
        int len = s1.size();
        for (int i = 1; i < len; 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(len-i);
            s22 = s2.substr(0, len-i);
            if (isScramble(s11, s21) && isScramble(s12, s22)) return true;
        }
        return false;
    }
};

思路2

还有一种解法是动态规划，为什么可以这样说呢？因为发现判断s1和s2是不是攀爬字符串时用到的是s1子串和s2子串的信息，即可以理解为用到了历史信息，所以可以考虑用动态规划来解决。我们考虑状态dp[i][j][len]代表从字符串s1的i位开始，字符串s2的第j位开始，长度为len的字符串是不是攀爬字符串。那么根据之前的递归思路，我们可以写出递推关系: 
dp[i][j][len] = dp[i][j][k]&&dp[i+k][j+k][len-k] || dp[i][j+len-k][k] && dp[i+k][j][len-k]。1 <= k < len，k可以理解为将字符串一分为二的那个位置。 
注意dp[i][j][k]这些存储的历史信息，这里我们要把len循环放在最外层。边界情况就是len==1的情况，需要先单独处理一下。

bool isScramble(string s1, string s2) {
        // write your code here
        if (s1.size() != s2.size()) return false;
        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][j+len-k][k] && dp[i+k][j][len-k]) {
                                dp[i][j][len] = true;
                            }
                    }
                }
            }
        }
        return dp[0][0][n];
    }