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

1、问题描述

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

示例 1： 
	输入: "babad" 
	输出: "bab" 注意: "aba" 也是一个有效答案。 
示例 2：
	输入: "cbbd"
	输出: "bb

2、预备知识介绍

回文字符串：一个字符串的反序和正序的顺序一致，就说是回文字符串。

3、问题分析

我们使用一个具体的例子来进行分析
      0 1 2 3 4 5 6 7 8 9 (字符的下标)
例子："a a b a a d a a b a"(这里的空格不算)
我们一般最常用的方法就是，遍历字符串的每一个字符，以当前的字符串为中心向两边扩展，如果两边相等，就是回文串，继续片判断；如果不相等则遍历下一个。如上面的字符串
"a a b a a d a a b a"
 0 1 2 3 4 5 6 7 8 9 
 遍历下标0时：回文串长度为1
 遍历下标1时：回文串长度应该为2，但是用上面的方法判断出来就是1，需要判断下标是偶数还是奇数，所以这里我们应该对原始字符串进行处理
 ......
 如何处理字符串？其实很简单，我们在字符串中间添加上特殊字符，如下
  0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19  
 "a # a # b # a # a # d   #   a   #   a   #   b   #   a   #"
 遍历下标0：长度为1
 遍历下标1：长度为3
 遍历下标2：长度为3
 遍历下标3：长度为1
 遍历下标4：长度为8
 遍历下标5：长度为1
 遍历下标6：长度为3
 遍历下标7：长度为3
 ...............

我们可以发现

较大的红框中是关于下标4中心对称，其实并不难理解因为回文子串就是关于中心对称的，
因此我们知道了左半边的长度情况，就不用了算右边的情况了，可以直接得出右边子串的回文长度。

我们把一个回文串长度看成一个左边界、中心点和右边界组成一个封闭的区间，当我们知道做区间的情况，
也就知道了有区间的情况

4、程序实现步骤

步骤：1、处理字符串，加上特殊的字符
步骤：2、定义一个与处理后数组串长度一样的数组记录字符串对应下标的回文长度的一半(便于计算)
步骤：3、定义一个变量最长回文串的中心点(int center)和长度(int halfLongestLen)的一半(便于计算)
步骤：4、定义记录右边界(rightSide)和右边界中心点(rightCenter)
步骤：5、下面请看程序实现部分，详细说明

 /**
     * 给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。
     * <p>
     * 示例 1：
     * 输入: "babad"
     * 输出: "bab"
     * 注意: "aba" 也是一个有效答案。
     * <p>
     * 示例 2：
     * 输入: "cbbd"
     * 输出: "bb"
     */

    public String longestPalindrome(String s) {
        if (s == null || s.length() == 0) return "";
        if (s.length() == 1) return s;

        //预处理字符串
        s = preHandString(s);

        //记录每个中心点的回文长度
        int[] halfLongArr = new int[s.length()];

        //记录最长回文子串的长度和中心点
        int center = 0;
        int longest = 0;

        //记录右边界
        int rightSide = 0;
        //右边界中心
        int rightSideCenter = 0;

        for (int i = 0; i < s.length(); i++) {
            //是否需要中心扩展
            boolean needExplore = true;

            //当前中心点是否小于右边界
            if (i < rightSide) {
                //计算得到相应以右边界中心点对称左边的回文中心点
                int leftCenter = 2 * rightSideCenter - i;
                halfLongArr[i] = halfLongArr[leftCenter];

                //存在问题，左边中心点的回文串很长，其长度越过当前右边界回文串的边界
                //进行调整
                if (i + halfLongArr[i] > rightSide) {
                    halfLongArr[i] = rightSide - i;
                }

                //根据计算出的回文子串小于右边界,不需要扩展
                if (i + halfLongArr[leftCenter] < rightSide) {
                    needExplore = false;
                }
            }
            //需要中心扩展
            if (needExplore) {
                while (i - 1 - halfLongArr[i] >= 0 && i + 1 + halfLongArr[i] < s.length()) {
                    if (s.charAt(i + 1 + halfLongArr[i]) == s.charAt(i - 1 - halfLongArr[i])) {
                        halfLongArr[i]++;
                    } else {
                        break;
                    }
                }
                //更新右边界及中心
                rightSide = i + halfLongArr[i];
                rightSideCenter = i;
                if (halfLongArr[i] > longest) {
                    center = i;
                    longest = halfLongArr[i];
                }
            }

        }
        //去掉之前加上去特殊字符
        StringBuilder sb = new StringBuilder();
        for (int i = center - longest; i <= center + longest; i += 2) {
            if ((i == center - longest) && s.charAt(i) == '#') {
                i = i - 1;
                continue;
            }
            sb.append(s.charAt(i));
        }
        return sb.toString();

    }