最长回文子串（Longest Palindromic Substring）——三种时间复杂度的解法及LeetCode[5] - 最长回文子串&&动态规划

最长回文子串（Longest Palindromic Substring）——三种时间复杂度的解法

原文地址：https://blog.csdn.net/qq_32354501/article/details/80084325

子串：小于等于原字符串长度由原字符串中任意个连续字符组成的子序列

    回文：关于中间字符对称的文法，即“aba”(单核)、“cabbac”(双核)等

    最长回文子串：1.寻找回文子串；2.该子串是回文子串中长度最长的。

一、O(n^3)时间复杂度方法——暴力求解

1.思想：

    1）从最长的子串开始，遍历所有该原字符串的子串；

    2）每找出一个字符串，就判断该字符串是否为回文；

    3）子串为回文时，则找到了最长的回文子串，因此结束；反之，则继续遍历。

 

2.时间复杂度解释：

    遍历字符串子串：嵌套一个循环、O(n^2)；   

    判断是否为回文：再次嵌套一个循环、O(n^3)。

 

3.java代码详解：    

public static String longestPalindrome(String s) {
        if(s.length() <= 1)
            return s;
        for(int i = s.length();i > 0; i--) {//子串长度
            for (int j = 0; j <= s.length() - i; j++) {
                String sub = s.substring(j , i + j);//子串位置
                int count = 0;//计数，用来判断是否对称
                for (int k = 0; k < sub.length() / 2; k++) {//左右对称判断
                    if (sub.charAt(k) == sub.charAt(sub.length() - k - 1))
                        count++;
                }
                if (count == sub.length() / 2)
                    return sub;
            }
        }
        return "";//表示字符串中无回文子串

    }

 

二、O(n^2)时间复杂度方法——从中心向外扩散

1.思想：

     1）将子串分为单核和双核的情况，单核即指子串长度为奇数，双核则为偶数；

    2）遍历每个除最后一个位置的字符index(字符位置)，单核：初始low = 初始high = index，low和high均不超过原字符串的下限和上限；判断low和high处的字符是否相等，相等则low++、high++（双核：初始high = 初始low+1 = index + 1）；

    3）每次low与high处的字符相等时，都将当前最长的回文子串长度与high-low+1比较。后者大时，将最长的回文子串改为low与high之间的；

    4）重复执行2）、3），直至high-low+1 等于原字符串长度或者遍历到最后一个字符，取当前截取到的回文子串，该子串即为最长的回文子串。

 

2.时间复杂度解释：

   遍历字符：一层循环、O(n-1)；

   找以当前字符为中心的最长回文子串：嵌套两个独立循环、O(2n*(n-1)) = O(n^2)。

 

3.java代码详解：

private static int maxLen = 0;

private static String sub = "";

public static String longestPalindrome(String s) {
        if(s.length() <= 1)
            return s;

        for(int i = 0;i < s.length()-1;i++){

            findLongestPalindrome(s,i,i);//单核回文

            findLongestPalindrome(s,i,i+1);//双核回文
        }
        return sub;
    }
    public static  void findLongestPalindrome(String s,int low,int high){
        while (low >= 0 && high <= s.length()-1){
            if(s.charAt(low) == s.charAt(high)){
                if(high - low + 1 > maxLen){
                    maxLen = high - low + 1;
                    sub = s.substring(low , high+1);
                }
                low --;//向两边扩散找当前字符为中心的最大回文子串
                high ++;
            }
            else
                break;
        }

    }

 

三、O(n)时间复杂度方法——Manacher算法

1.思想：

    1）将原字符串S的每个字符间都插入一个永远不会在S中出现的字符（本例中用“#”表示），在S的首尾也插入该字符，使得到的新字符串S_new长度为2*S.length()+1，保证Len的长度为奇数(下例中空格不表示字符，仅美观作用)；

        例：S：       a  a  b  a  b  b  a

        S_new:        #  a  #  a  #  b  #  a  #  b  #  b  #  a  #

    2）根据S_new求出以每个字符为中心的最长回文子串的最右端字符距离该字符的距离，存入Len数组中，即S_new[i]—S_new[r]为S_new[i]的最长回文子串的右段（S_new[2i-r]—S_new[r]为以S_new[i]为中心的最长回文子串），Len[i] = r - i + 1;

        S_new:        #  a  #  a  #  b  #  a  #  b  #  b  #  a  #

        Len:            1  2  3  2  1   4  1  4  1  2  5   2  1  2  1

        Len数组性质：Len[i] - 1即为以Len[i]为中心的最长回文子串在S中的长度。在S_new中，以S_new[i]为中心的最长回文子串长度为2Len[i] - 1，由于在S_new中是在每个字符两侧都有新字符“#”，观察可知“#”的数量一定是比原字符多1的，即有Len[i]个，因此真实的回文子串长度为Len[i] - 1，最长回文子串长度为Math.max(Len) - 1。

    3）Len数组求解（线性复杂度（O(n)））：

       a.遍历S_new数组，i为当前遍历到的位置，即求解以S_new[i]为中心的最长回文子串的Len[i];

       b.设置两个参数：sub_midd = Len.indexOf(Math.max(Len)表示在i之前所得到的Len数组中的最大值所在位置、sub_side = sub_midd + Len[sub_midd] - 1表示以sub_midd为中心的最长回文子串的最右端在S_new中的位置。起始sub_midd和sub_side设为0，从S_new中的第一个字母开始计算，每次计算后都需要更新sub_midd和sub_side；

      c.当i < sub_side时，取i关于sub_midd的对称点j（j = 2sub_midd - i，由于i <= sub_side，因此2sub_midd - sub_side <= j <= sub_midd);当Len[j] < sub_side - i时，即以S_new[j]为中心的最长回文子串是在以S_new[sub_midd]为中心的最长回文子串的内部，再由于i、j关于sub_midd对称，可知Len[i] = Len[j];

    当Len[j] >= sub.side - i时说明以S_new[i]为中心的回文串可能延伸到sub_side之外，而大于sub_side的部分还没有进行匹配，所以要从sub_side+1位置开始进行匹配，直到匹配失败以后，从而更新sub_side和对应的sub_midd以及Len[i]；

 

        d.当i > sub_side时，则说明以S_new[i]为中心的最长回文子串还没开始匹配寻找，因此需要一个一个进行匹配寻找，结束后更新sub_side和对应的sub_midd以及Len[i]。

 

2.时间复杂度解释：

        算法只有遇到还没匹配的位置时才进行匹配，已经匹配过的位置不再进行匹配，因此大大的减少了重复匹配的步骤，对于S_new中的每个字符只进行一次匹配。所以该算法的时间复杂度为O(2n+1)—>O(n)（n为原字符串的长度），所以其时间复杂度依旧是线性的。

 

3.java代码详解：

public String longestPalindrome(String s) {
        List<Character> s_new = new ArrayList<>();
        for(int i = 0;i < s.length();i++){
            s_new.add('#');
            s_new.add(s.charAt(i));
        }
        s_new.add('#');
        List<Integer> Len = new ArrayList<>();
        String sub = "";//最长回文子串
        int sub_midd = 0;//表示在i之前所得到的Len数组中的最大值所在位置
        int sub_side = 0;//表示以sub_midd为中心的最长回文子串的最右端在S_new中的位置
        Len.add(1);
        for(int i = 1;i < s_new.size();i++){
            if(i < sub_side) {//i < sub_side时，在Len[j]和sub_side - i中取最小值，省去了j的判断
                int j = 2 * sub_midd - i;
                if(j >= 2 * sub_midd - sub_side &&  Len.get(j) <= sub_side - i){
                    Len.add(Len.get(j));
                }
                else
                    Len.add(sub_side - i + 1);
            }
            else//i >= sub_side时，从头开始匹配
                Len.add(1);
            while( (i - Len.get(i) >= 0 && i + Len.get(i) < s_new.size()) && (s_new.get(i - Len.get(i)) == s_new.get(i + Len.get(i))))
                Len.set(i,Len.get(i) + 1);//s_new[i]两端开始扩展匹配，直到匹配失败时停止
            if(Len.get(i) >= Len.get(sub_midd)){//匹配的新回文子串长度大于原有的长度
                sub_side = Len.get(i) + i - 1;
                sub_midd = i;
            }
        }
        sub = s.substring((2*sub_midd - sub_side)/2,sub_side /2);//在s中找到最长回文子串的位置
        return sub;

    }

 

 

LeetCode[5] - 最长回文子串&&动态规划

原文地址：https://www.jianshu.com/p/a7741619dd58

题目

给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为1000。

示例 1：

输入: "babad"
输出: "bab"
注意: "aba"也是一个有效答案。

示例 2：

输入: "cbbd"
输出: "bb"

tips: 回文字符串：正读反读都一样

叙事

这道题目level为中等，读第一遍我就觉得可能会很棘手，当然立刻就有一个简单的解题思路，因为知道这种解法很烂所以一直没有coding。直到有一天····

 

强迫症

 

强迫症患者根本无法继续愉快coding了。。。只好不拖延，解决这个棘手的问题····当然肯定是因为自己菜才觉得棘手···

分析

最简单能想到的解决方案就是把字符串的所有子串枚举出来，每一个都判断是否是回文字符串，然后选长度最长的回文子串。。。后来我才知道这个算法叫暴力算法···名字很酷···暴力足以解决很多问题····代码很简单

 public String longestPalindrome(String s) {
        if(s.isEmpty()){
            return s;
        }
        String res=s.substring(0,1);
        for (int i = 0; i < s.length(); i++) {
            for (int j = i + 1; j <= s.length(); j++) {
                String k=s.substring(i,j);
                String rk=new StringBuffer(k).reverse().toString();
                if(k.equals(rk)&&k.length()>res.length()){
                    res=k;
                }
            }

        }
        return res;
    }

一段不加注释都能看得懂的代码···我们执行了一下····

 

完美gg

 

果然···暴力的leetcode都看不过去···
现有的知识和智慧已经不够用了。然后去google解法。最强的是一个叫马拉车的算法，看起来有点复杂，而且对其他算法题帮助不大，所以拖拉的楼主决定晚点再学这个马拉车。接下来就是动态规划算法。。。等我起一个title。

动态规划

为什么单独将动态规划罗列出来呢，因为这在算法问题中好像十分普遍和重要。楼主之前刷面试题，很多算法问题的answer 作者都直接甩一句动态规划···好，今天就直面曾经欠下的债。动态规划颇有点“大事化小，小事化了”的感觉。在动态规划中有三个重要的元素最优子结构，边界，状态转移公式，我们稍后结合一个例子理解一下这仨概念~
理解动态规划有一个最典型的例子：
有面值分别为1，3，5的三种硬币若干，需要凑成11元最少需要多少硬币，凑成n元最少需要多少硬币？
和往常一样我们来一起找规律：
假如：

• 凑成0元需要0个硬币 //d(0)=0
• 凑成1元需要1个1元硬币 //d(1)=d(0)+1
• 凑成2元需要2个1元硬币 //d(2)=d(1)+1
• 凑成3元需要3个1元硬币或者1个3元硬币，那么我们选择1个3元硬币 //d(3)=min{d(2)+1,d(3-3)+1}
• 凑成4元需要1个3元硬币，1个1元硬币 //d(4)=d(3)+1;
• 凑成5元需要1个3元硬币，2个1元硬币或者1个5元硬币，那么我们选择1个5元硬币 //d(5)=min{d(4)+1,d(5-5)+1}
• 。。。。
• 抽离出来d(i)=min{ d(i-1)+1,d(i-vj)+1 }，其中i-vj >=0，vj表示第j个硬币的面值;

这里d(i-1)+1和d(i-vj)+1是d(i)的最优子结构，d(0)=0是边界，d(i)=min{ d(i-1)+1,d(i-vj)+1 }是状态转移公式。其实我们根据边界+状态转移公式就能得到最终动态规划的结果。
上述程序的java实现

public int dp(int n) {
        n++;
        int min[] = new int[n];
        int[] V = {1, 3, 5};
        min[0]=0;
        for (int i = 1; i < n; i++) {
            min[i] =  min[i-1]+1;
            for (int j = 0; j < V.length; j++) {
                if (V[j] > i) {
                    break;
                }
                if (min[i - V[j]] < min[i-1]) {
                    min[i] = min[i - V[j]] + 1;
                }
            }
        }
        return min[n - 1];
    }

因为我也是今天才去了解动态规划，所以有可能有些理解不对表述不对的地方。欢迎指出。
关于动态规划我看了的两篇文章：
动态规划：从新手到专家
参考：程序员小灰动态规划

动态规划解决最长回文子串

我们创建一个二维数组，boolean[][]dp,其中dp[i][j]表示字符串第i到j是否为回文。那么边界值其实很清楚了，j-i=1的都为true 字符串长度为1的都为true。状态转换如何设定呢？当字符串i所在的字符等于字符串j所在的字符，并且它的内部(dp[i+1][j-1])为回文那么dp[i][j]为true。因为这样的规律，我们要保证判断dp[i][j]的时候dp[i+1][j-1]已经判断，所以我们遍历采用i降序j升序的嵌套遍历的方式

    public String longestPalindrome(String s) {
        if (s.isEmpty()) {
            return s;
        }
        int n = s.length();
        boolean[][] dp = new boolean[n][n];
        int left = 0;
        int right = 0;
        for (int i = n - 2; i >= 0; i--) {
            dp[i][i] = true;
            for (int j = i + 1; j < n; j++) {
                dp[i][j] = s.charAt(i) == s.charAt(j) &&( j-i<3||dp[i+1][j-1]);//小于3是因为aba一定是回文
                if(dp[i][j]&&right-left<j-i){
                    left=i;
                    right=j;
                }
            }
        }
        return s.substring(left,right+1);
    }

这次我们再运行，发现顺利通过leetcode的考验~~
测试用例：dsfsdhadhfkdsdsfsdhadhdsfsdhadhfkddsfsdhadhfkdsahfksadhdsfsdhadhfkdsahfksadhfksddsfsdhadhfkdsahfksadhfksdhfusdihfksjadfhksadjkdsahfdsjkhfksdhffhiawoeuruihweiyrtiuoncsdbfzmbfkhfioaewncfhskdsfsdhadhfkdsahfksadhfksdhfusdihfksjadfhksadjkdsahfdsjkhfksdhffhiawoeuruihweiyrtiuoncsdbfzmbfkhfioaewncfhskhfusdihfksjadfhksadjkdsahfdsjkhfksdhffhiawoeuruihweiyrtiuoncsdbfzmbfkhfioaewncfhskdsfsdhadhfkdsahfksadhfksdhfusdihfksjadfhksadjkdsahfdsjkhfksdhffhiawoeuruihweiyrtiuoncsdbfzmbfkhfioaewncfhskdsfsdhadhfkdsahfksadhfksdhfusdihfksjadfhksadjkdsahfdsjkhfksdhffhiawoeuruihweiyrtiuoncsdbfzmbfkhfioaewncfhskdsfsdhadhfkdsahfksadhfksdhfusdihfksjadsfsdhadhfkdsahfksadhfksdhfusdihfksjadfhksadjkdsahfdsjkhfksdhffhiawoeuruihweiyrtiuoncsdbfzmbfkhfioaewncfhskdsfsdhadhfkdsahfksadhfksdhfusdihfksjadfhksadjkdsahfdsjkhfksdhffhiawoeuruihweiyrtiuoncsdbfzmbfkhfioaewncfhskdfhksadjkdsahfdsjkhfksdhffhiawoeuruihweiyrtiuoncsdbfzmbfkhfioaewncfhskfdsfsdhadhfkdsahfksadhfksdhfusdihfksjadfhksadjkdsahfdsjkhfksdhffhiawoeuruihweiyrtiuoncsdbfzmbfkhfioaewncfhskksdhfusdihfksjadfhksadjkdsahfdsjkhfksdhffhiawoeuruihweiyrtiuoncsdbfzmbfkhfioaewncfhsksahfksadhfksdhfusdihfksjadfhksadjkdsahfdsjkhfksdhffhiawoeuruihweiyrtiuoncsdbfzmbfkhfioaewncfhskfkdsahfksadhfksdhfusdihfksjadfhksadjkdsahfdsjkhfksdhffhiawoeuruihweiyrtiuoncsdbfzmbfkhfioaewncfhskahfksadhfksdhfusdihfksjadfhksadjkdsahfdsjkhfksdhffhiawoeuruihweiyrtiuoncsdbfzmbfkhfioaewncfhsk

结果

作者：sxqiong
链接：https://www.jianshu.com/p/a7741619dd58
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。