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.分析：
这个问题是google的面试题。因为一个字符串有不少种二叉表示法，貌似很难判断两个字符串是否能够作这样的变换。
对付复杂问题的方法是从简单的特例来思考，从而找出规律。
先考察简单状况：
字符串长度为1：很明显，两个字符串必须彻底相同才能够。
字符串长度为2：当s1="ab", s2只有"ab"或者"ba"才能够。
对于任意长度的字符串，咱们能够把字符串s1分为a1,b1两个部分，s2分为a2,b2两个部分，知足（(a1~a2) && (b1~b2)）或者 （(a1~b2) && (a1~b2)）

如此，咱们找到了解决问题的思路。首先咱们尝试用递归来写。

解法一（递归）:
两个字符串的类似的必备条件是含有相同的字符集。简单的作法是把两个字符串的字符排序后，而后比较是否相同。
加上这个检查就能够大大的减小递归次数。
代码以下：

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

解法二（动态规划）：
固然，这道题也能够用动态规划Dynamic Programming，根据以往的经验来讲，根字符串有关的题十有八九能够用DP来作，那么难点就在于如何找出递推公式。参见网友Code Ganker的博客，这实际上是一道三维动态规划的题目，咱们提出维护量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)。代码以下：

 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 };