给定一个字符串，求出其最长回文子串。例如：

给定一个字符串，求出其最长回文子串（回文字符串就是从左到右读和从右往左读完全一样，也就是字符串关于中间对称）。例如：

1. s = "babad"，最长回文长度为`3`，可以是`bab` 或者`aba`；

2. s = "cbbda"，最长回文长度为`2`，即`bb`；

3. s = "abcde"，最长回文长度为`1`，即单个字符本身。

等同于LeetCode上的第五题：[Longest Palindromic Substring](https://leetcode.com/problems/longest-palindromic-substring)

这个问题等同于LeetCode上的[Longest Palindromic Substring](https://leetcode.com/problems/longest-palindromic-substring)。

其相关题解可以查看这里：[传送门](https://github.com/Blankj/awesome-java-leetcode/blob/master/note/005/README.md)

以上问题的传统思路大概是，遍历每一个字符，以该字符为中心向两边查找。其时间复杂度为`O(n2)`，效率很差。

以上问题的传统思路大概是遍历每一个字符，以该字符为中心向两边查找，其时间复杂度为`O(n2)`，效率很差。

1975 年，一个叫 Manacher 的人发明了一个算法，Manacher 算法（中文名：马拉车算法），该算法可以把时间复杂度提升到`O(n)`。下面来看看马拉车算法是如何工作的。

1975年，一个叫 Manacher 的人发明了一个算法，Manacher 算法（中文名：马拉车算法），该算法可以把时间复杂度提升到`O(n)`，下面按我理解的思路来讲解其原理。

最后一种思路那就是`Manacher's Algorithm`，中文名叫马拉车算法，该算法就是专为解决此问题而发明的，其时间复杂度提升到了线性。下面我以我理解的思路来讲解其原理。

由于回文串的奇偶行不确定，比如`lol` 是奇回文，而`lool` 是偶回文，马拉车算法的第一步就是对其进行预处理，做法就是在每个字符两侧都加上一个特殊字符，一般就是不会出现在原串中的即可，我们可以选取`#`，那么

`lol` ->`#l#o#l#`

`lool` ->`#l#o#o#l#`

这样处理后，不管原来字符串长度是奇数还是偶数，最终得到的长度都将是奇数，从而能把两种情况合并起来一起考虑，记预处理后的字符串为`str`。

我们把一个回文串中最左或最右位置的字符与其对称轴的距离称为回文半径。

马拉车算法定义了一个回文半径数组`len`，用`len[i]` 表示以第`i` 个字符为对称轴的回文串的回文半径，比如以`str[i]` 为中心的最长回文串是`str[l, r]`，那么`len[i] = r - i + 1`

我们以`lollool` 为例，参看下表。

| str| #| l| #| o| #| l| #| l| #| o| #| o| #| l| #|

| :---| :---| :---| :---| :---| :---| :---| :---| :---| :---| :---| :---| :---| :---| :---| :---|

| len| 1| 2| 1| 4| l| 2| 3| 2| 1| 2| 5| 2| 1| 2| 1|

可以发现`len[i] - 1` 就等于该回文串在原串中的长度。

证明：在转换后的字符串`str` 中，那么对于以`str[i]` 为中心的最长回文串的长度为`2 * len[i] - 1`,其中又有`len[i]` 个分隔符，所以在原字符串中的长度就是`len[i] - 1`。

packagecom.blankj.hard._044;

importjava.util.ArrayList;

importjava.util.Collections;

importjava.util.List;

publicbooleanisMatch(Strings,Stringp) {

if (p.length() ==0)returns.length() ==0;

intsl =s.length(),pl =p.length();

boolean[][]dp =newboolean[sl +1][pl +1];

char[]sc =s.toCharArray(),pc =p.toCharArray();

dp[0][0] =true;

for (inti =1;i <=pl; ++i) {

if (pc[i -1] =='*')dp[0][i] =dp[0][i -1];

publicList<String>fullJustify(String[]words,intmaxWidth) {

intlen =words.length;

if (len ==0)returnCollections.emptyList();

List<String>ans =newArrayList<>();

StringBuilderspaces =newStringBuilder();

for (inti =0;i <maxWidth; ++i) {

spaces.append(" ");

}

for (inti =1;i <=sl; ++i) {

for (intj =1;j <=pl; ++j) {

if (pc[j -1] !='*') {

dp[i][j] =dp[i -1][j -1] && (sc[i -1] ==pc[j -1] ||pc[j -1] =='?');

intsLen = -1,left =0;

for (inti =0;i <len; ++i) {

if (sLen +words[i].length() +1 <=maxWidth) {

sLen +=words[i].length() +1;

}else {

StringBuildersub =newStringBuilder(words[left]);

intrest =maxWidth -sLen;

intseg =i -left;

if (seg ==0) {

sub.append(spaces.substring(0,rest));

}else {

dp[i][j] =dp[i][j -1] ||dp[i -1][j];

intleastSpace =rest /seg +1;

intrestSpace =rest %seg;

for (intj =left +1;j <i; ++j) {

if (restSpace-- >0) {

sub.append(spaces.substring(0,leastSpace +1)).append(words[j]);

}else {

sub.append(spaces.substring(0,leastSpace)).append(words[j]);

}

}

}

ans.add(sub.toString());

left =i;

sLen =words[i].length();

}

}

returndp[sl][pl];

StringBuildersub =newStringBuilder(words[left]);

for (inti =left +1;i <len; ++i) {

sub.append(" ").append(words[i]);

}

ans.add(sub +spaces.substring(0,maxWidth -sub.length()));

returnans;

}

publicstaticvoidmain(String[]args) {

Solutionsolution =newSolution();

System.out.println(solution.isMatch("aa","a"));// false

System.out.println(solution.isMatch("aa","aa"));// true

System.out.println(solution.isMatch("aaa","aa"));// false

System.out.println(solution.isMatch("aa","*"));// true

System.out.println(solution.isMatch("aa","a*"));// true

System.out.println(solution.isMatch("ab","?*"));// true

System.out.println(solution.isMatch("aab","c*a*b"));// false

System.out.println(solution.fullJustify(newString[]{"",""},0));

System.out.println(solution.fullJustify(newString[]{"a"},1));

System.out.println(solution.fullJustify(newString[]{"This","is","an","example","of","text","justification."},16));

}

}