【力扣每日一题】扰乱字符串

美好的一天，从每日一题结束。

使用下面描述的算法可以扰乱字符串 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 。

虽然它被分在了字符串里，但事实上
这是一道动态规划。
首先，它是可以分解的——从题目不难看出，“扰乱字符串”其实是可逆可拆的。
如果a和b是扰乱字符串，c与d是扰乱字符串，那么a+c与b+d就是扰乱字符串
那么，想要验证s1与s2是否是扰乱字符串就不难想了
将s1与s2各分成两部分，看s11与s21、s12与s22是否互为扰乱字符串（然后交换舞伴），如果成了就成了，如果不成就换个位置分。
然后是一些细节的东西，比如遍历要从小到大，因为使用了记忆化，在验证后面时一定会调用前面的结果
打个比方
s1 = 12345678
s2 = 32154876
验证12345 对 32154 678 与 876 时
只讨论前者，12345和32154分成 123 45 与 321 54，这里的123 与321 在前面讨论123 45678 与 321 54876 时已经有了结果。
剩下就是边缘处理了，当两个字符串相同时互为扰乱，长度不同时必不是扰乱。如果两个字符串里字符数量类型不同必不是扰乱。
在验证这个的时候我用了一个猥琐的方法
复制两个temp字符串，给它们排序然后比较……如果为了追求空间可以用匿名函数吧，但我没什么追求。
剩下的……也没啥了。
上代码！我写了好久！这要是面试当场就放弃了。

class Solution {
public:
    int record[30][30][31];
    string s1,s2;
    bool dp(int i,int j,int k)
{
	if(record[i][j][k])
        return record[i][j][k] == 1;
    if (s1.substr(i,k) == s2.substr(j,k))
	{
        record[i][j][k] = 1;
        return true;
    }
	string tempa = s1.substr(i,k);
	string tempb = s2.substr(j,k);
	sort(tempa.begin(), tempa.end());
	sort(tempb.begin(), tempb.end());
	if (tempa != tempb)
    {
        record[i][j][k] = -1;
        return false;
    }
	for(int m = 1; m < k; m++)
    {
        if(dp(i,j,m) && dp(i+m,j+m,k-m))
        {
            record[i][j][k] = 1;
            return true;
        }
        if(dp(i,j+k-m,m) && dp(i+m,j,k-m))
        {
            record[i][j][k] = 1;
            return true;
        }
    }
        record[i][j][k] = -1;
        return false;
}
    bool isScramble(string s1, string s2) 
    {
        memset(record,0,sizeof(record));
        this -> s1 = s1;
        this -> s2 = s2;
        return dp(0,0,s1.size());
    }
};

结果，还行吧，空间时间大概百分之五十多这样子。

                                           *你能找到一个，能接受你全部的人吗*