这两题都涉及到一个小细节，就是数组个数的奇偶和下标的关系。一个数组的个数是n，下标就是0到n-1；如果n是奇数，(n-1)/2就是中间元素的下标，如果n是偶数，(n-1)/2和n/2就是位于中间的两个元素；而且，n是奇数时，n/2等于(n-1)/2，这个细节在处理二分等需要定位数字中间位置的问题时可以简化思考。

反过来想，任意一个数组，通过在各元素中间插入分隔符(含首位)，得到的新数组个数一定为奇数(2n+1)：
[1,2,3,4,5] — [#,1,#,2,#,3,#,4,#,5,#]
[1,2,3,4] — [#,1,#,2,#,3,#,4,#]
且新数组中下标i，对应原数组下标i/2，下面两个问题都可以利用这一点统一算法的逻辑。

4.两个排序数组的中位数

给定两个大小为 m 和 n 的有序数组 nums1 和 nums2 。
请找出这两个有序数组的中位数。要求算法的时间复杂度为 O(log (m+n)) 。
示例 1:
nums1 = [1, 3]
nums2 = [2]
中位数是 2.0
示例 2:
nums1 = [1, 2]
nums2 = [3, 4]
中位数是 (2 + 3)/2 = 2.5

这个时间复杂度的要求也变相的进行了提示，O(log(n))是类似二分法的时间复杂度。不过这种思考问题的方式并不可取，容易限制思路，没有这个要求我们也应该要想到理论上最优的方法。 怎么想到呢？这里就要充分利用已排序这一前提条件，二分查找的原理都知道，就是从一个已排序的数组中快速找到某个元素。本题只不过变成两个数组，查找的是这两个数组中第(m+n)/2小的元素。

假设我们队nums1进行二分，根据二分的位置可以在nums2中找到相应的一个位置，使得两个数组的前半部分相加刚好是一半：
a1,a2,,,ai / ai+1,…,am
b1,b2,…,bj / bj+1,…,bn
对于个数为奇数的数组，我们假设这个“/”在中位数中间，即：[1，(2 / 2)，3]
如果刚好满足ai<=bj+1 且 bj<=ai+1，那么中位数一定就是(max(ai,bj)+min(ai+1,bj+1))/2，反之就继续进行二分。

再考虑到前面提到的小技巧，可以将这两个数组分别变成个数为2m+1和2n+1的数组，免去分类讨论的情形。我们得到的是类似如下的数组：
原数组为奇数个 ： [#,1,#,2,#,3,#,4,#,5,#]
原数组为偶数个 ： [#,1,#,2,#,3,#,4,#]
我们用l和r分别表示分割左右的两个元素，假设某一时刻二分的分割下标是c，则不论个数是奇数还是偶数，l和r在原数组中的下标一定是(c-1)/2和c/2。

算法写出来就是：
（参考自https://legacy.gitbook.com/book/hk029/leetbook/details）

class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int m = nums1.length, n = nums2.length;
        if (m == 0) return findMedianSortedArray(nums2);
        if (n == 0) return findMedianSortedArray(nums1);
        if (m > n) return findMedianSortedArrays(nums2,nums1);
        int c1,c2,l=0,h=2*m;
        int l1=0,r1=0,l2=0,r2=0;
        while (l <= h) {
            c1 = (l+h)/2;
            // c1确定后，c2取m+n-c1，保证两个数组左边个数相加等于右边
            c2 = m+n-c1;
            // num1二分的左边，边界时取最小值不影响 Math.max(l1,l2)的结果
            l1= (c1 == 0) ? Integer.MIN_VALUE : nums1[(c1-1)/2];
            // num1二分的右边，边界时取最大值不影响 Math.min(r1,r2)的结果
            r1= (c1 == 2*m) ? Integer.MAX_VALUE : nums1[c1/2];
            // nums2对应的分割左右边，同上
            l2= (c2 == 0) ? Integer.MIN_VALUE : nums2[(c2-1)/2];
            r2= (c2 == 2*n) ? Integer.MAX_VALUE : nums2[c2/2];

            if (l1 > r2) {
                h = c1-1;
            }
            else if (l2 > r1) {
                l = c1+1;
            }
            else break;
        }
        return (Math.max(l1,l2) + Math.min(r1,r2))/2.f;
    }

    double findMedianSortedArray(int[] nums) {
        int n = nums.length;
        if (n == 0) return -1;
        else return (nums[(n-1)/2]+nums[n/2])/2.f;
    }
}

5.最长回文子串

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

假设我们遍历数组，并以每个点为中心查找最长回文子串，这样下来时间复杂度为O(n^2)。在这个过程中，我们并没有利用字符串匹配的特殊性，做了大量不必要的重复匹配。想想一下当我们匹配以i为中心的回文串时，其实已经知道了以i-1和之前的点为中心的最长回文串，如果之前最长的回文子串包含i，则根本不需要再计算i。这里直接贴一个Manacher算法的思路，下一篇会整理一下关于字符串匹配的相关内容。

和上一题类似的地方是，长度为奇数的回文串是aba，abcba这种形式；偶数则是abba，abccba这种形式。我们同样可以使用插入分隔符的方法将这两种形式统一起来：
“#a#b#a#”
“#a#b#b#a#”
这样都变成了奇数形式。Manacher算法适合计算长度为奇数的回文串，正好可以利用这个方法。

关于Manacher算法的内容可以参考 Manacher算法总结
代码：

class Solution {
    public String longestPalindrome(String s) {
        int bound=0,id=0,max=0;
        StringBuilder p = new StringBuilder();
        p.append('$');
        p.append('#');
        for (int i = 0; i < s.length(); i ++) {
            p.append(s.charAt(i));
            p.append('#');
        }
        p.append('\0');
        int[] P = new int[p.length()-1];
        Arrays.fill(P,1);
        for(int i=1;i < p.length()-1; i++) {
            if(i < bound) {
                P[i] = Math.min(bound-i,P[2*id-i]);
            }
            while(p.charAt(i-P[i]) == p.charAt(i+P[i])) {
                P[i] = P[i]+1;
            }
            if(i+P[i] > bound) {
                bound = i+P[i];
                id = i;
            }
            max = P[i] > P[max]?i:max;
        }
        return s.substring((max-P[max])/2,(max+P[max])/2-1);
    }
}