再一次的动态规划涨知识了leetcode 第5题

首先是我昨天在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);

综上所述，我发现自己还是有很多的不足，首先就是对题目算法的敏感程度很低，其次就是找到了递推公式却也最后没能第一时间做出来，动态规划没有那么简单，抱着自满的心态是肯定远远不够的，记录一次自己的失败经历，同时也希望可以把这道题深深的印在自己脑子里，让自己以后处理事情的思路不要太暴力，也许换个思路就是答案，我却固执的一条路走到黑。