美好的一天,从每日一题结束。
使用下面描述的算法可以扰乱字符串 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());
}
};
结果,还行吧,空间时间大概百分之五十多这样子。
*你能找到一个,能接受你全部的人吗*