马拉车算法

马拉车算法用于寻找字符串中的最长回文子串。

java

class ManacherAlgo {
    String longestPalindrome(String s) {
        // 填充
        String newS = fillStr(s);

        // center是中心，right是中心的最远覆盖范围，max_center是最长回文字串的中心
        int right = 0, center = 0, max_center = 0;

        // 记录每个位置的最远覆盖范围
        int[] radius = new int[newS.length()];
        int lenOfNewS = newS.length();

        // 算法主体
        for (int idx = 1; idx < lenOfNewS; idx++) {
            if (idx < right) {
                int mirror = 2 * center - idx;
                radius[idx] = Math.min(right - idx, radius[mirror]);
            } else
                radius[idx] = 1;

            while (
                    (idx + radius[idx] < lenOfNewS) &&
                            (idx - radius[idx] >= 0) &&
                            (newS.charAt(idx + radius[idx]) == newS.charAt(idx - radius[idx]))
            )
                radius[idx]++;

            if (idx + radius[idx] > right) {
                right = idx + radius[idx];
                center = idx;
            }

            if (radius[idx] > radius[max_center]) {
                max_center = idx;
            }
        }

        // 返回最长回文字串
        int l = max_center - radius[max_center];
        int r = max_center + radius[max_center];
        return s.substring((l + 1) / 2, r / 2);
    }

    // 填充
    private String fillStr(String s) {
        StringBuilder retS = new StringBuilder("#");
        for (int i = 0; i < s.length(); i++) {
            retS.append(s.charAt(i)).append("#");
        }

        return retS.toString();
    }

    // 测试
    public void testing() {
        System.out.println(longestPalindrome("abababbb"));
        System.out.println(longestPalindrome("aba"));
        System.out.println(longestPalindrome("aa"));
    }
}

public class manacher {

    public static void main(String[] args) {
        // 生成实例
        ManacherAlgo obj = new ManacherAlgo();

        // 测试
        obj.testing();
    }
}

python

# coding=utf-8
"""
author:shayue
2019/09/18
"""


class Manacher():
    """
    算法步骤：
    1. 输入要操作的字符串后，先进行填充，这一步的目的是为了无视奇偶差异，填补后的字符串长度必为奇数；
    2. 从左往右遍历，以位置center为中心，往两边扩散，记录最大回文子串的半径，比如12321，其半径为3，将半径放入列表radius中；
    3. 利用先前已经保存的半径信息，可以加快后序位置所对应回文子串的半径求解，具体实现见longest_palindromic_substring。
    """
    def __init__(self, inputStr):
        self.str_ = inputStr
        self.right = 0
        self.center = 0         #
        self.radius = None      # 列表

        # 下面两个变量是为了找到最长子串
        self.MaxPi = 0
        self.Max_Pi_center = 0


    def longest_palindromic_substring(self):
        """
        马拉车算法，找到最大回文子串并返回
        :return: str
        """
        filled_s = self.fill_to_s()
        self.P = [0] * len(filled_s)
        print(filled_s)

        for idx in range(1, len(filled_s)):
            if idx < self.right:
                mirror = self.get_mirror(idx)
                self.P[idx] = min(self.right - idx, self.P[mirror])
            else:
                self.P[idx] = 1

            while idx - self.P[idx] >= 0 and \
            idx + self.P[idx] < len(filled_s) and \
            filled_s[idx - self.P[idx]] == filled_s[idx + self.P[idx]]:
                self.P[idx] += 1

            if self.P[idx] + idx > self.right:
                self.right = self.P[idx] + idx
                self.center = idx

            if self.P[idx] > self.MaxPi:
                self.MaxPi = self.P[idx]
                self.Max_Pi_center = idx

        l = self.Max_Pi_center - self.MaxPi
        r = self.Max_Pi_center + self.MaxPi
        return self.str_[(l+1) // 2: r // 2]

    def get_mirror(self, i):
        """
        以self.center为中心，返回位置i对应到左边的位置mirror
        :param i: 位置i，在self.center右边
        :return: 位置mirror，在self.center左边
        """
        return 2 * self.center - i

    def fill_to_s(self):
        """
        对self.s进行'#'填充，填充完后的字符串总长为奇数，以便算法对奇偶情况都适用
        :return: str
        """
        retStr = "#" + "#".join(self.str_) + '#'
        return retStr


if __name__ == '__main__':
    manacher = Manacher('abcababacab')
    print(manacher.longest_palindromic_substring())
    print(manacher.P)