首先是我昨天在leetcode上做了一道题leetcode 第5题 最长回文子串,我很想当然的采用了暴力解法,结果超时了
后来当我静下心来读了一下这道题,我发现这是可以用动态规划进行解决
给你一个字符串 s,找到 s 中最长的回文子串。
输入:s = “babad”
输出:“bab”
解释:“aba” 同样是符合题意的答案。
当然,我是实在太笨了看了一眼题解,因为临时有个会要开就去开会没有继续写下去。
直到今天早上我一觉醒来发现有思路了(我发誓我就昨天看了一眼题解)
根据回文字符串的特点,我们可以从一个字符串的中心看,假设这个字符串的一个字符的两边是相同的字母,那么这三个字符一定是一个回文串,那么不妨定义一个二维数组dp[i][j]来表示从i 到 j 的一个子串是否是回文串
根据上述我的个人理解不难看出dp[i][j] = dp[i+1][j-1]是true的同时 s[i] == s[j]
所以dp[i][j] = d[i+1][j-1] && s[i] == s[j]
好,既然有了一个大体上的递推公式下一步应该就是考虑边界条件了,对于本题来说,边界条件无疑是一个字符必然是回文串这样一句话,所以很自然地写出这样一串代码
boolean[][] f = new boolean[s.length()][s.length()];
//i 和 j 相等的时候一定是
for(int i=0;i<s.length();i++){
f[i][i] = true;
}
然后我的噩梦开始了,我以为的边界条件只有这些(本人太菜了的后果),于是我继续用了两层for循环,外层 i 从0开始,内层 j 从i + 2 开始,于是一切按部就班的写完,我发现我忽略了一件事,如果只有两个字符怎么办,或者说当处理的子问题变成两个字符的时候该怎么办?
于是傻傻的我又加了这样一串代码
if(s.length() == 1){
return s;
}
if(s.length() == 2){
if(s.charAt(0) == s.charAt(1))
return s;
else
return s.substring(0,1);
}
对此我只想对当时的自己说, nice!
可惜后来问题又来了,我外层循环从 i 开始 内层循环从 j = i + 2开始,那子问题变成两个字符的串该怎么办?于是我很自然地把 j 变成了j = i+1,之后我的代码修修补补就变成了这幅惨样
for(int i=0;i<s.length();i++){
for(int j=i+1;j<s.length();j++){
if(j-i+1 == 2){
if(s.charAt(i) == s.charAt(j)){
f[i][j] = true;
}else{
f[i][j] = false;
}
}else {
if (f[i + 1][j - 1] && (s.charAt(i) == s.charAt(j))) {
f[i][j] = true;
} else {
f[i][j] = false;
}
}
}
}
好,测试样例过了,可是当出现"aaaa"这样一个字符串时,我返回的居然只是"aaa",此时的我还没有意识到问题的严重性,所幸写了一个判断是否是回文串的子函数,并加在了开头(没错,我离动态规划越来越远了)
public boolean isHui_Wen(String str){
int mid = str.length() / 2;
for(int i=0;i<mid;i++){
if(str.charAt(i) != str.charAt(str.length() - i - 1)){
return false;
}
}
return true;
}
//以上是子函数的定义
//以下是代码开头加上的恶心东西
if(isHui_Wen(s))
return s;
if(s.length() == 1){
return s;
}
if(s.length() == 2){
if(s.charAt(0) == s.charAt(1))
return s;
else
return s.substring(0,1);
}
后来当再一次的提交失败,我发现了我的问题所在,原来究其根本是我每次判断dp[i][j]的时候,dp[i+1][j-1]都是false,因为我根本没有处理dp[i+1][j-1]这个子问题,不禁陷入了深深的思考!
于是我做出了一个大胆的决定,每次dp[i][j]都用上次写的函数判断一下是否是回文数,是就true,不是就false;
好,OK兄弟们,全体目光向我看齐,我宣布个事。。。。。我的动态规划变成了暴力破解!!!(代码就不上了,要脸)
所以如何解决dp[i+1][j-1]的问题呢? 我改变了一下思路,变成了先处理列,再处理行,于是重振旗鼓更新版的for循环出现了
for(int j=1;j<s.length();j++){
for(int i=0;i<j;i++){
这样就可以保证dp[i+1][j-1]的子问题永远存在了,还是忍不住吐槽自己实在是太菜了,于是接下来就很顺理成章的来了灵感,首先判断i j是否相等,其次再判断是否小于3 最后再根据dp[i+1][j-1]决定dp[i][j]的状态
for(int j=1;j<s.length();j++){
for(int i=0;i<j;i++){
if(s.charAt(i) != s.charAt(j)){
f[i][j] = false;//头尾都不一样,肯定不是回文
}else{
//头尾一样看里面
if(j - i + 1 < 3){
//说明里面要么没有,要么一个,必然是回文
f[i][j] = true;
}else{
f[i][j] = f[i+1][j-1];
}
}
}
}
好,到了这一步,只需要最后找到最长的回文串就好了,于是我终于历经千难万苦度过了这一劫难。
可是当我看题解的时候我发现,原来我还是个小笨蛋,找最大子串这一步完全不需要再O(n)循环一遍dp数组,只需要在数组的处理过程中找到就好了,在此感谢这位大佬
于是最后的结果变成了这个样子
//这道题可以用动态规划来做
//设置dp[i][j] 为从i 到 j 的字符串是否是回文串
//如果dp[i+1][j-1]是回文串,那么dp[i+1][j-1]并且s[i] == s[j] 上得出dp[i][j]一定是回文串
boolean[][] f = new boolean[s.length()][s.length()];
//i 和 j 相等的时候一定是
for(int i=0;i<s.length();i++){
f[i][i] = true;
}
int b = 0;
int max = 1;
//这道题的状态转移应该先算列的才可以
for(int j=1;j<s.length();j++){
for(int i=0;i<j;i++){
if(s.charAt(i) != s.charAt(j)){
f[i][j] = false;//头尾都不一样,肯定不是回文
}else{
//头尾一样看里面
if(j - i + 1 < 3){
//说明里面要么没有,要么一个,必然是回文
f[i][j] = true;
}else{
f[i][j] = f[i+1][j-1];
}
}
//存住起始位置
if(f[i][j] && j - i + 1 > max){
max = j - i + 1;
b = i;
}
}
}
return s.substring(b,b+max);
综上所述,我发现自己还是有很多的不足,首先就是对题目算法的敏感程度很低,其次就是找到了递推公式却也最后没能第一时间做出来,动态规划没有那么简单,抱着自满的心态是肯定远远不够的,记录一次自己的失败经历,同时也希望可以把这道题深深的印在自己脑子里,让自己以后处理事情的思路不要太暴力,也许换个思路就是答案,我却固执的一条路走到黑。