Markdown版本笔记	我的GitHub首页	我的博客	我的微信	我的邮箱
MyAndroidBlogs	baiqiantao	baiqiantao	bqt20094	[email protected]

领扣-5 最长回文子串 Longest Palindromic Substring MD

最长回文子串 Longest Palindromic Substring

动态规划

问题

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

示例 1：

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

示例 2：

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

暴力循环法1

class Solution {
    public String longestPalindrome(String s) {
        if (s.length() == 0) return s;

        String palindrome = s.substring(0, 1);
        for (int i = 0; i < s.length(); i++) {
            for (int j = i + 1; j < s.length(); j++) {
                char[] array = s.substring(i, j + 1).toCharArray();
                for (int k = 0; k < array.length / 2; k++) {
                    if (array[k] != array[array.length - 1 - k]) {
                        break;
                    }
                    if (k == array.length / 2 - 1) {
                        String sub = s.substring(i, j + 1);
                        palindrome = palindrome.length() > sub.length() ? palindrome : sub;
                    }
                }
            }
        }
        return palindrome;
    }
}

提交时提示超出时间限制

时间复杂度：O(n^3)
空间复杂度：O(1)

暴力循环法2

class Solution {
    public String longestPalindrome(String s) {
        if (s.length() == 0) return s;

        String candidate = s.substring(s.length() - 1);
        if (s.equals(new StringBuilder(s).reverse().toString())) {
            return s;
        } else {
            int len = s.length();
            for (int i = 0; i < len; i++) {
                for (int j = i + 1; j < len; j++) {
                    String str = s.substring(i, j + 1);
                    if (str.equals(new StringBuilder(str).reverse().toString())) {
                        if (str.length() > candidate.length()) {
                            candidate = str;
                        }
                    }
                }
            }
            return candidate;
        }
    }
}

同样超时(速度还不如上面的呢)！

动态规划(不懂)

为了改进暴力法，我们首先观察如何避免在验证回文时进行不必要的重复计算。

考虑 “ababa” 这个示例。如果我们已经知道 “bab” 是回文，那么很明显，“ababa” 一定是回文，因为它的左首字母和右尾字母是相同的。

我们给出 P(i,j) 的定义如下：

P(i,j) =
\begin{cases}
{true, 如果子串 S_i ... S_j 是回文子串}\
{false, 其它情况}
\end{cases}

因此：

P(i, j) = P(i+1, j-1) and  S(i) == S(j)

基本示例如下：

P(i,i) = true
P(i, i+1) = (S(i) == S(i+1))

这产生了一个直观的动态规划解法，我们首先初始化一字母和二字母的回文，然后找到所有三字母回文，并依此类推…

class Solution {
    public String longestPalindrome(String s) {
        if (s == null || s.length() < 1) return "";
        int len = s.length();
        String res = "";
        int max = 0;
        boolean[][] dp = new boolean[len][len];//创建一个行列均为字符串长度的二维数组，创建时默认初始化为false
        for (int j = 0; j < len; j++) {
            for (int i = 0; i <= j; i++) {//这里只考虑了i<=j的情况，因为i>j时均为false
                //当i==j,j-i==1,j-i==2时，只要满足s.charAt(i) == s.charAt(j)就是回文字符串
                //如果不是这样，还要判断当前回文字符串的子串是不是回文字符串，即dp[i + 1][j - 1])，这就是动 态规划思想
                dp[i][j] = s.charAt(i) == s.charAt(j) && (j - i <= 2 || dp[i + 1][j - 1]);
                if (dp[i][j]) {//如果是回文字符串
                    if (j - i + 1 > max) {//并且比之前的回文字符串要长，更新字符串长度，记录字符串
                        max = j - i + 1;
                        res = s.substring(i, j + 1);
                    }
                }
            }
        }
        return res;
    }
}

时间复杂度：O(n^2)
空间复杂度：O(n^2)

中心扩展算法(不懂)

class Solution {
    public String longestPalindrome(String s) {
        if (s == null || s.length() < 1) return "";
        int start = 0, end = 0;
        for (int i = 0; i < s.length(); i++) {
            int len1 = expandAroundCenter(s, i, i);
            int len2 = expandAroundCenter(s, i, i + 1);
            int len = Math.max(len1, len2);
            if (len > end - start) {
                start = i - (len - 1) / 2;
                end = i + len / 2;
            }
        }
        return s.substring(start, end + 1);
    }

    private int expandAroundCenter(String s, int left, int right) {
        int L = left, R = right;
        while (L >= 0 && R < s.length() && s.charAt(L) == s.charAt(R)) {
            L--;
            R++;
        }
        return R - L - 1;
    }
}

时间复杂度：O(n^2)

Manacher算法(不懂)

class Solution {
    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;
    }
}

时间复杂度：O(n)

2018-12-10