最长回文子串

最新推荐文章于 2024-11-20 18:03:38 发布

JIANG_RZJ

最新推荐文章于 2024-11-20 18:03:38 发布

阅读量155

点赞数

分类专栏： leetcode

本文链接：https://blog.youkuaiyun.com/JIANG_RZJ/article/details/88745037

版权

leetcode 专栏收录该内容

7 篇文章

订阅专栏

不同于最长回文子序列, 它可以用动态规划来求解, 但是最长回文子串要求的子字符串在原字节数组中是连续的.

【1】暴力求解

例如，对于任何长度的字符串, aabaa, 在每一个字符的后加上一个特殊字符, 比如 a# a# b# a# a#, 这样就变成了偶数个,能够处理无法扩充的问题.

a # a # b # a # a #

1 3 3 1 10 1 3 5 3 1

这样不断由自己向两边扩充解出答案. 但时间复杂度是o(n^2)

【2】Manacher算法

假如由如下回文, 省略 #

a b c d e f .... k .... g a o m w u

因为要求最长的回文串, 我们定义[L, C, R], 这个表示以C为中心, L是回文串的开始索引, R是回文串的结束索引.

一开始初始化时 R(全) = -1，

我们求以每一个元素为C，得到R,L就能得出谁是最长的回文串, 但是每一次扩充的过程并非独立的.

比如一开始求第0个元素的R和L，L无法扩充, 我们通过暴力搜索直接算出R。然后更新R(全), 这样，就分两种情况,

例如接下来求第一个元素的R和L，第一个元素的index <= R(全), 或者 index > R(全)

[1] 我们先来看第一种情况, 可以抽象的理解为:

... L(全) C(全) R(全) i

假设我们要求出i的r, 可以看到当前的 i 位置 > R(全), 无法通过最大的那一次求解来帮助我们这一次的求解, 只能暴力扩充。

[2] 第二种情况

... L(全) i(映射) C(全) i R(全) ..

我们可以看到 i 出现在 R(全）左边, 此时根据C(全) 映射到i(映射) 位置，这时可以根据i(映射)的L和R分情况讨论：

2.1 如果 i(映射) 的 L和R 包含在当前全局最大范围的L和R中, 那么i的L和R可以直接得出: i的回文串范围和i(映射的一样)

... L(全) x1 L(i映射的l ) i(映射) i(映射的r) y1 C(全) y2 L(i) i R(i) x2 R(全) ..

证明如下：因为从L(全) 到 C(全) 的字符串是从C(全）到 R(全) 的逆序, 所以 x1=x2, y1=y2, 那么x1一定不等于y1, 如果相等那不就是i(映射)的L和R求错了吗？所以 y2 != x2, 所以 i的回文范围无法扩充, 只能和 i(映射)保持一致...

2.2 如果 i(映射) 的L 出现在 L(全）的左边, 如下:

l(map_i)... x1L map_i x2 R(map_i) C y2 i Ry1 ...

那么 i 的回文范围也不用暴力扩充, 它的R = R(全).

证明: x1 与 x2 关于 map_i 对称，因此 x1 = x2;

x2 与 y2 关于 C 对称, 因此 x2 = y2

所以 x1 = y2 ，但 x1 != y1 的事实，即y2 != y1, 扩充失败......

2.3 剩下一种情况是 L(全) 的位置和 L(i的映射) 重合, 这时候, 根据情况2.1, 可以得出结论外, 无法排除 i 继续扩充的可能性, 需要暴力扩充......

public String manacher(String str) {
        if (str.length() == 1) {
            return str;
        }
        StringBuilder sb = new StringBuilder();
        sb.append("#");
        for (int i = 0;i < str.length();i++) {
            sb.append(str.charAt(i) + "#");
        }
        char[] cs = sb.toString().toCharArray();
        // right[i] 表示 以 i为中心, 最大回文字符串最右索引位置
        int right[] = new int[cs.length];
        int C = -1, R = -1;
        int maxIndex = -1; int max_R = -1;
        for (int i = 0;i < cs.length;i++) {
            if (i <= R) {
                
                // 找到i(映射)
                // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
                // a # a # b # b # b # b  #  a  #  a  #
                // h # g # g # h # a # a  #  b  #  b  #  b  #  a  #  a  #
                int y_i =  2 * C - i; 
                int y_i_r = right[y_i];
                int y_i_l = y_i - (y_i_r - y_i);
                int L = 2 * C - R;
                if (y_i_l > L) {
                    right[i] = y_i_r - y_i + i;
                } else if (y_i_l < L) {
                    right[i] = R;
                } else {
                    right[i] = getRightIndex(cs, i);
                }
                
            } else {
                // 暴力扩充
                right[i] = getRightIndex(cs, i);
            }
            if (right[i] > R) {
                C = i;
                R = right[i];
                if (R - C > max_R - maxIndex) {
                    max_R = R;
                    maxIndex = C;
                }
            }
        }
        int t = max_R - maxIndex;
        return new String(cs, maxIndex - t, 2 * t ).replace("#", "");
    }
    private int getRightIndex(char[] cs, int index) {
        int left = index;
        int right = index;
        while (left > 0 && right < cs.length-1) {
            if (cs[left-1] == cs[right+1]) {
                left--;
                right++;
            } else {
                return right;
            }
        }
        return right;
    }

最后问题：现有一个字符串, 只能在后面添加字符, 如何做到添加最少字符串, 将之变成回文串?