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

以下是 C++ 的实现代码：

class Solution {
public:
    bool isScramble(string s1, string s2) {
        if (s1 == s2) {
            return true;
        }
        int n = s1.size();
        vector<vector<vector<bool>>> dp(n, vector<vector<bool>>(n, vector<bool>(n + 1)));
        for (int len = 1; len <= n; ++len) {
            for (int i = 0; i + len <= n; ++i) {
                for (int j = 0; j + len <= n; ++j) {
                    if (len == 1) {
                        dp[i][j][len] = s1[i] == s2[j];
                    } else {
                        for (int k = 1; k < len; ++k) {
                            if (dp[i][j][k] && dp[i + k][j + k][len - k]) {
                                dp[i][j][len] = true;
                                break;
                            }
                            if (dp[i][j + len - k][k] && dp[i + k][j][len - k]) {
                                dp[i][j][len] = true;
                                break;
                            }
                        }
                    }
                }
            }
        }
        return dp[0][0][n];
    }
};

其中 dp[i][j][len] 表示 s1 从 i 开始长度为 len 的子串是否能变换为 s2 从 j 开始长度为 len 的子串。根据题意，对于 len > 1 的情况，枚举 s1 和 s2 分割成的两个子串的长度 k（1 <= k < len），然后分两种情况讨论：

1. 交换两个子串，对应 s1[i:i+k-1] 和 s2[j+len-k:j+len-1] 能否互相变换，以及 s1[i+k:i+len-1] 和 s2[j:j+len-k-1] 能否互相变换。
2. 不交换两个子串，对应 s1[i:i+k-1] 和 s2[j:j+k-1] 能否互相变换，以及 s1[i+k:i+len-1] 和 s2[j+k:j+len-1] 能否互相变换。

如果存在一种方案满足条件，就可以将 dp[i][j][len] 置为 true。

最终答案即为 dp[0][0][n]，表示整个字符串能否变换为目标字符串。