LEETCODE 87. 扰乱字符串

题目描述：

使用下面描述的算法可以扰乱字符串 s 得到字符串 t ：

    如果字符串的长度为 1 ，算法停止
    如果字符串的长度 > 1 ，执行下述步骤：
        在一个随机下标处将字符串分割成两个非空的子字符串。即，如果已知字符串 s ，则可以将其分成两个子字符串 x 和 y ，且满足 s = x + y 。
        随机 决定是要「交换两个子字符串」还是要「保持这两个子字符串的顺序不变」。即，在执行这一步骤之后，s 可能是 s = x + y 或者 s = y + x 。
        在 x 和 y 这两个子字符串上继续从步骤 1 开始递归执行此算法。

给你两个 长度相等 的字符串 s1 和 s2，判断 s2 是否是 s1 的扰乱字符串。如果是，返回 true ；否则，返回 false 。

解题思路：

题目是典型的动态规划可解，把一个大问题，化解成了小问题。

要判断整个字符串是不是扰乱字符串，就先从子字符串（长度为1，2，3……）开始判断。

dp[l][i][j]表示长度为l的字符串，s1的起点为i,s2的起点为j，用k去划分该字符串，

如果s1[i....i+k-1]==s2[j.....j+k-1] 且s1 [i+k.....i+l-1]==s2[j+k......j+l-1]，则为扰乱字符串。

或者如果s1[i....i+k-1]==s2[j+l-k.....j+l] 且s1 [i+k....i+l] == s2[j.....j+l-k-1], 则为扰乱字符串。

要注意k不能为0，因为题目要求划分为两个非空子字符串。

C++代码如下：

 bool isScramble(string s1, string s2) {
        if(s1.size()!=s2.size()) return false;
        int n = s1.size();
        bool dp[n+1][n][n];
        fill_n(&dp[0][0][0], (n+1)*n*n,false);
        for(int i=0;i<n;i++){
                for(int j=0;j<n;j++){
                    dp[1][i][j] = s1[i]==s2[j];
                }
        }

        for(int l=1;l<=n;l++){
            for(int i=0;i+l<=n;i++){
                for(int j=0;j+l<=n;j++){
                    for(int k=1;k<l;k++){
                        if( (dp[k][i][j] && dp[l-k][i+k][j+k])
                             || ( dp[k][i][j+l-k] &&　dp[l-k][i+k][j] )
                         ){
                            dp[l][i][j] = true;
                            break;
                        }
                    }
                }
            }
        }

        return dp[n][0][0];
    }