力扣第五题 5.最长回文子串

无敌の星仔

已于 2024-06-03 16:23:10 修改

阅读量577

点赞数 22

分类专栏： LeetCode解题文章标签： leetcode 算法职场和发展

于 2024-06-03 15:39:46 首次发布

本文链接：https://blog.csdn.net/XingZaiUnrivaled/article/details/139391437

版权

LeetCode解题专栏收录该内容

10 篇文章 0 订阅

订阅专栏

问题

解题思路

我们的回文子串有两种情况，一种是左与右相同，一种是左与右+1的位置所以我们就可以根据这个条件判断是否为子串，然后再扩大判断。

还可以使用中心扩展的方式，就判断左右相等然后外扩，然后呢我们可以调用两次这个方法，一次由左右，一次由左右+1的方式进行发觉。

我和官方比较了一下还是相对领先的，领先了一点点。

动态规划

class Solution {
    public String longestPalindrome(String s) {
        if (len < 2) {
            return s;
        }
        int len = s.length();
        int left = 0, right = 0, res = 0;
        boolean[][] dp = new boolean[len][len];
        for (int i = len - 1; i >= 0; i--) {
            for (int j = i; j < len; j++) {
                if (s.charAt(i) == s.charAt(j) && (j - i < 2 || dp[i + 1][j - 1])) {
                    dp[i][j] = true;
                    if (j - i > res) {
                        res = j - i;
                        left = i;
                        right = j;
                    }
                }
            }
        }
        return s.substring(left, right + 1);
    }
}

长度小于2直接返回，然后我们用经典动态规划的数组进行保存字符是否相同然后在同时确定他不会超出2格范围也就是0~1,0代表中间没有间隔字符类似aa，1就是代表中间为aba，所以我们就判断是否小于2假如不在这个范围我们再用动态规划保存i+1,j-1的状态进行判断长这样。

/*
      b a b a d

    b t f t f f
    a f t f t f
    b t f t f f
    a f t f t f
    d f f f f t
*/

假如在判断a的时候就忘左上角判断一下是否存在，如果存在引入条件。

然后我们在进入的条件里面进行下一步的执行，然后再判断如果间隔大于原本存的大小则进行保存下标为之后的切割做准备。

中心扩展

class Solution {
    public String longestPalindrome(String s) {
        int n = s.length();
        if (n < 2) {
            return s;
        }
        String res = "";
        for (int i = 0; i < n; i++) {
            String s1 = palindrome(s, i, i);
            String s2 = palindrome(s, i, i + 1);
            res = s1.length() > res.length() ? s1 : res;
            res = s2.length() > res.length() ? s2 : res;
        }
        return res;
    }

    private String palindrome(String s, int l, int r) {
        while (l >= 0 && r < s.length() && s.charAt(l) == s.charAt(r)) {
            l--;
            r++;
        }
        return s.substring(l + 1, r);
    }
}

中心扩展，我们在解题思路里面说道过的道理，然后在我们自建的中心扩展的方法里面的判断方式也很简单，不越界且满足回文条件。但是这个有问题，因为写的时候是返回的字符串，就是切割动作做多了会影响速度。所以我们改成返回下标。

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

    private int palindrome(String s, int l, int r) {
        while (l >= 0 && r < s.length() && s.charAt(l) == s.charAt(r)) {
            l--;
            r++;
        }
        return r - l - 1;
    }
}

这里我们就改成了下标的方式，然后在本体里面判断一下让我们要切的范围为最大且里面则是不要忘记使用右移且不要忘记位移的优先级比加减低所以不要忘记加括号。

我上面贴的图就是用这个跑出来的。

官方解法

1.动态规划

public class Solution {

    public String longestPalindrome(String s) {
        int len = s.length();
        if (len < 2) {
            return s;
        }

        int maxLen = 1;
        int begin = 0;
        // dp[i][j] 表示 s[i..j] 是否是回文串
        boolean[][] dp = new boolean[len][len];
        // 初始化：所有长度为 1 的子串都是回文串
        for (int i = 0; i < len; i++) {
            dp[i][i] = true;
        }

        char[] charArray = s.toCharArray();
        // 递推开始
        // 先枚举子串长度
        for (int L = 2; L <= len; L++) {
            // 枚举左边界，左边界的上限设置可以宽松一些
            for (int i = 0; i < len; i++) {
                // 由 L 和 i 可以确定右边界，即 j - i + 1 = L 得
                int j = L + i - 1;
                // 如果右边界越界，就可以退出当前循环
                if (j >= len) {
                    break;
                }

                if (charArray[i] != charArray[j]) {
                    dp[i][j] = false;
                } else {
                    if (j - i < 3) {
                        dp[i][j] = true;
                    } else {
                        dp[i][j] = dp[i + 1][j - 1];
                    }
                }

                // 只要 dp[i][L] == true 成立，就表示子串 s[i..L] 是回文，此时记录回文长度和起始位置
                if (dp[i][j] && j - i + 1 > maxLen) {
                    maxLen = j - i + 1;
                    begin = i;
                }
            }
        }
        return s.substring(begin, begin + maxLen);
    }
}

对于官方的动归来说，比起我写的略微有点麻烦，所以可以考虑先用我写的简化版动归。

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);
    }

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

对比官方的中心扩展算法来说，他使用的是/2所以速度会稍微慢一些，其他的和我的大差不差。

3.Manacher 算法

class Solution {
    public String longestPalindrome(String s) {
        int start = 0, end = -1;
        StringBuffer t = new StringBuffer("#");
        for (int i = 0; i < s.length(); ++i) {
            t.append(s.charAt(i));
            t.append('#');
        }
        t.append('#');
        s = t.toString();

        List<Integer> arm_len = new ArrayList<Integer>();
        int right = -1, j = -1;
        for (int i = 0; i < s.length(); ++i) {
            int cur_arm_len;
            if (right >= i) {
                int i_sym = j * 2 - i;
                int min_arm_len = Math.min(arm_len.get(i_sym), right - i);
                cur_arm_len = expand(s, i - min_arm_len, i + min_arm_len);
            } else {
                cur_arm_len = expand(s, i, i);
            }
            arm_len.add(cur_arm_len);
            if (i + cur_arm_len > right) {
                j = i;
                right = i + cur_arm_len;
            }
            if (cur_arm_len * 2 + 1 > end - start) {
                start = i - cur_arm_len;
                end = i + cur_arm_len;
            }
        }

        StringBuffer ans = new StringBuffer();
        for (int i = start; i <= end; ++i) {
            if (s.charAt(i) != '#') {
                ans.append(s.charAt(i));
            }
        }
        return ans.toString();
    }

    public int expand(String s, int left, int right) {
        while (left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)) {
            --left;
            ++right;
        }
        return (right - left - 2) / 2;
    }
}

我每期都要放官方的解法，但是这个解法可以看官方的解释。

如果对你有帮助的话不要忘记点赞收藏。