每天一道LeetCode-----最长回文子串/序列，从头开始的最长回文子串长度

Longest Palindromic Substring

原题链接 Longest Palindromic Substring

意思是找到最长的回文子串，注意子串和子序列的区别

蛮力法就将每个可能的子串都找出来判断是否是回文子串，找最大的那一个，速度上慢的吓人，光找子串的速度就到O(n2)了，所以此处需要找到一个简单的方法找到回文子串。
既然回文子串是从中心开始向两边延伸时，左右两边相同，那么就可以从每个字符开始都向两边延伸，看能找到的最长回文子串是多长就行了。

这就出现了一个问题，回文子串的中心是什么地方，对于abcba来说，中心是c。那么对于abccba呢，中心是cc中间的位置，这个位置没有明确的下标。二者的区别在于一个数量上一个是奇数，一个是偶数。为了统一，这里有一种技巧，就是将源字符串s统一转化成奇数个数，方法是虚拟的加上一些字符，注意是虚拟加，实际上并不改变源s，假设s为babad，那么加上虚拟字符的s是#b#a#b#a#d#，这样，不管什么字符串全都是奇数个数了，总数为2 * s.size() + 1，而这里还有一个巧妙的地方，就是加上虚拟字符后的字符的索引除以2正好是在源s中没有加上虚拟字符的索引，这里把加上虚拟字符后的s成为extend_s

#   b   #   a   #   b   #   a   #   d   #   extend_s
0   1   2   3   4   5   6   7   8   9   10  extend_s的下标索引
0   0   1   1   2   2   3   3   4   4   5   除以2后的结果b   a   b   a   d   s
0   1   2   3   4   s的下标索引

所以在程序中遍历extend_s时只需要除以2，就可得得到s中对应位置的字符。

扩展s是为了解决奇数偶数的问题，这个问题存在在什么地方呢。比方说要找的结果是abccba，那么在切割的时候是从cc中间切分的，而对于abcba而言，切分是在c字符上切分的，这个还好说，切分的位置有正常的索引下标，可是abccba的切分位置是中间，下标是x.5?，不存在的。所以扩展后的s刚好解决的就是这个难题

a   b   c   c   b   a   源字符串s
0   1   2   3   4   5   下标索引|切分位置#   a   #   b   #   c   #   c   #   b   #   a   #   扩展字符串extend_s
0   1   2   3   4   5   6   7   8   9   10  11  12  下标索引|切分位置
-----------------------------------------------------------------a   b   c   b   a   源字符串s
0   1   2   3   4   下标索引|切分位置#   a   #   b   #   c   #   b   #   a   #   扩展字符串extend_s
0   1   2   3   4   5   6   7   8   9   10  下标索引|切分位置

通过扩展，不管是奇数个数的字符串还是偶数个数的字符串，都有一个明确的下标表示切分位置，这个位置正是回文子串的中心。程序就简单多了，从extend_s的每一个字符开始，向两边扩展，相等则继续扩展，不相等则停止扩展。需要注意的是，程序中遍历的仍然是源字符串s，只是在下标上做了点手脚，所以区分#还是字母的方法就看下标是奇数还是偶数，#的下标永远是偶数。代码如下

class Solution {
public:string longestPalindrome(string s) {if(s.size() <= 1)return s;string ans("");for(int i = 0; i < 2 * s.size() + 1; ++i){   /* 以extend_s[i]为中心，向两边扩展，这个extend_s[i]既有可能是#，也有可能是字母 */find_palindrome(i - 1, i + 1, s, ans);}return ans;}
private:void find_palindrome(int lhs_idx, int rhs_idx, std::string& s, std::string& ans){/* 判断边界 */while(lhs_idx >= 0 && rhs_idx < 2 * s.size() + 1){/* #的下标永远是偶数，所以判断是否是奇数，然后比较s中的两个字符 */if(lhs_idx % 2 != 0 && rhs_idx % 2 != 0 && s[lhs_idx / 2] != s[rhs_idx / 2]){break;}--lhs_idx;++rhs_idx;}/* * 这是为了解决边界0的问题，因为如果找到左边界(0)时仍然相等，那么lhs_idx会是-1* 因为找到的回文子串应该是s[lhs_idx / 2 + 1, rhs_idx / 2 - 1]* 由于lhs_idx是-1，-1/2==0，正常结果应该是s[0, rhs_idx / 2 - 1]，* 会导致lhs_idx / 2 + 1 == 1，不为0，使结果长度变小* 下面会说另一种解决办法*/if(lhs_idx == -1)lhs_idx = -2;if(static_cast<int>(ans.size()) < rhs_idx / 2 - lhs_idx / 2 - 1){ans = s.substr(lhs_idx / 2 + 1, rhs_idx / 2 - lhs_idx / 2 - 1);}}
};

因为左边界会有使结果长度变小的风险，上述程序中手动将lhs_idx从-1改为-2使lhs_idx/2为-1不为0。另一种解决办法是在extend_s头部再添加一个字符@代表头部，也可以解决上述问题。

Palindromic Substrings

原题链接Palindromic Substrings

和上面的题差不多，找所有可能的回文子串的数量，即使回文子串一样，但是在源s中的起止位置不同，也算作不同的回文子串，方法和上面一样，也需要添加虚拟字符，记得数个数。

class Solution {
public:int countSubstrings(string s) {int cnt = 0;for(int i = 0; i < 2 * s.size() + 1; ++i){/* 如果不是虚拟字符，+1 */if(i % 2 != 0){++cnt;}find_palindrome(i - 1, i + 1, s, cnt);}return cnt;}private:void find_palindrome(int lhs_idx, int rhs_idx, std::string& s, int& cnt){while(lhs_idx >=0 && rhs_idx < 2 * s.size() + 1){if(lhs_idx % 2 != 0 && rhs_idx % 2 != 0){if(s[lhs_idx / 2] == s[rhs_idx / 2])++cnt;elsebreak;}--lhs_idx;++rhs_idx;}}
};

Longest Palindromic Subsequence

原题链接Longest Palindromic Subsequence

和上面不同的是，这个是求最长的回文子序列，子序列是将源字符串中的任意多个字符删除后生成的新字符串，结果串中挨着的两个字符在源字符串中不一定是挨着的，因为二者中间可能有被删掉的字符。

这个就不能用上述方法解决了，因为如果s[lhs_idx / 2] != s[rhs_idx / 2]，那么s[lhs_idx / 2]还有可能和lhs_idx / 2前面的某个字符相等，构成子序列，所以上述方法行不通。
涉及到子序列的题可以这样想，假设len[i, j]表示范围[i, j]内最长的回文子序列长度，那么有两种情况

s[i] == s[j]，那么len[i, j]一定等于2 + len[i + 1, j - 1]
s[i] != s[j]，那么len[i, j] = max(len[i + 1, j], len[i, j - 1])

典型的动态规划，直接上代码（这里采用非递归方式）

class Solution {
public:int longestPalindromeSubseq(string s) {if(s.size() <= 1)return s.size();std::vector<std::vector<int> > dp(s.size(), std::vector<int>(s.size(), 0));for(int i = 0; i < s.size(); ++i)dp[i][i] = 1;/* * 递归的动态规划是从最大范围递归到单个字符然后逐层返回* 非递归就是实现逐层返回的方法，从单个字符扩展到最大范围*/for(int i = s.size() - 1; i >= 0; --i){for(int j = i + 1; j < s.size(); ++j){if(s[i] == s[j]){dp[i][j] = 2;if(i + 1 <= j - 1)dp[i][j] += dp[i + 1][j - 1];}else{dp[i][j] = std::max(dp[i][j - 1], dp[i + 1][j]);}}}return dp[0][s.size() - 1];}
};

设计到子序列的问题，或者可以转换成上述两种可能的问题都是动态规划的典型问题，动态规划在算法中使用频率很高，常见问题是IO背包，很重要！！！！

Shortest Palindrome

原题链接Shortest Palindrome

意思是给定一个源字符串s，在s的头部添加尽可能少的字符，使s成为一个回文字符串。
既然在头部添加，那么s[0]一定是扩展后的中心吗，不一定，题中第一个例子就是反例。
那么在头部前面添加的一定就是源字符串s较后面的几个字符，这样才能达到最少，也就是说需要找到源s中从头开始最长的回文子串，然后将后面的多余部分添加到头部，只有这样才有可能是最小的。

a a c e c a a  a|分割，前面是s最长的回文子串，且从头开始
只需要把多出的a也添加到头部即可a b c c b a  d a f g h|分割，理由同上

所以要求就转换成了，寻找源字符串s最长的回文子串，要求这个子串从源s的起始位置开始。
这就很麻烦了，既不能使用上面的方法从每个字符开始向两边扩展，也不能直接从头开始判断每个子串是否是回文串（太麻烦，复杂度过高），因为如果用这种方法，就需要

固定头部，从尾部开始找第一个和s[0]相等的位置back
判断s[0, back]是否是个回文串，如果是，结束，如果不是，接着找第二个和s[0]相等的位置

这样来来回回遍历了好几遍，况且如果源s重复度过高（每一个都和s[0]相等），那么遍历的次数就更多了，显然不合适。

解决这一问题用到了KMP算法（第一次见KMP可以求回文串）
首先复习一下KMP吧，先别着急想怎么用KMP解决这道题。
KMP，字符串处理算法，典型的问题是在一个源字符串中判断是否包含某个子串，相比于普通的一个一个比较，KMP可以实现多字符跳过，不需要比较没有的字符，大大提高的运行效率。
KMP算法的核心在于根据源字符串构建前缀数组
前缀数组中的元素含义是上一个和当前字符相等的位置 + 1，同时当前字符的前几个字符也都有这些位置，并且位置不间断一直到1，这个位置+1同时也表示第几个字符（从1开始），举个例子

0   1   2   3   4   5   6   7   8   9   10  下标索引
a   b   c   a   b   c   a   a   b   a   c   源字符串s
0   0   0   1   2   3   4   1   2   1   0   前缀数组/*
解释：
s[0] == a，前面没有字符，初始为0
s[1] == b, 第一个字符a和b不相等，为0
s[2] == c，同上
s[3] == a，和第一个字符a相等，为0 + 1 = 1，表示s[3]前面和自己相等的字符是第1个字符
s[4] == b，和前面s[3]记录的位置1（第1个字符）后面的位置2（第2个字符）b相等，为2
s[5] == c，同上，和第3个字符c相等，为3
s[6] == a，同上，和第4个字符a相等，为4
s[7] == a，和前面s[6]记录的位置4（第4个字符）后面的位置5（第5个字符）b不相等找第4个字符a记录的位置1（第1个字符）后面的位置2（第2个字符）b不相等找第2个字符b记录的位置0(第0个字符）后面的位置1（第1个字符）a相等，为1
s[8] == b，和前面s[7]记录的位置1（第1个字符）后面的位置2（第2个字符）b相等，为2
s[9] == a，和前面s[8]记录的位置2（第2个字符）后面的位置3（第3个字符）c不相等，找第2个字符b记录的位置0（第0个字符）后面的位置1（第1个字符）a相等，为1
s[10]== c，和前面s[9]记录的位置1（第1个字符）后面的位置2（第2个字符）b不相等，找第2个字符b记录的位置0（第0个字符）后面的位置1（第1个字符）a不相等，找第1个字符a记录的位置0（第0个字符）后面的位置1（第1个字符）a不不相等，....有个规定，到达0时如果和第1个字符仍然不相等，记为0
*/

构造的代码就比较容易写了，如下

void treat_prefix(std::string& extend_s, int *prefix)
{int l = 0;prefix[0] = 0;for(int i = 1; i < extend_s.size(); ++i){/* 其实每次l都等于prefix[i - 1]，只是在跳的过程中一直prefix[prefix[i - 1] - 1] *//* 如果一直不相等，一直往前跳，直到为0 */while(l > 0 && extend_s[i] != extend_s[l])l = prefix[l - 1];if(extend_s[i] == extend_s[l])++l;prefix[i] = l;}
}bool kmp(std::string& source, std::string target)
{int *prefix = new int[target.size()];treat_prefix(target, prefix);int l = 0;for(int i = 0; i < source.size(); ++i){/** 跟source[i]比较，如果你不和我l位置的字符相等* 那我跳到前面，看看咱俩相不相等* 因为kmp算法的前缀数组保证，跳到前面后，target[0, l - 1]这部分仍然是和source[i - l - 1, i - 1]相等的，不需要重复比较*/while(l > 0 && source[i] != target[l])l = prefix[l - 1];if(source[i] == target[l])++l;if(l == target.size())return true;;}return false;
}

其实上面的从0开始的最长回文子串只用到了prefix数组，方法是先将源字符串s扩展，扩展方式如下

std::string reverse_s(s.rbegin(), s.rend()); //求s的翻转字符串
s = s + "#" + reverse_s;

假设s为catacb，那么扩展后的s为

catacb#bcatac

对此调用生成前缀数组的函数

0   1   2   3   4   5   6   7   8   9   10  11  12  下标索引
c   a   t   a   c   b   #   b   c   a   t   a   c   扩展后的s
0   0   0   0   1   0   0   0   1   2   3   4   5   prefix数组假设源字符串（未扩展）从0开始的最长回文子串为从s[i]到s[j]，
那么子串s[i]到s[j]和翻转后从s[j]到s[i]肯定相等，因为回文字符串的特性，翻转后仍然相等
那么假设扩展后这段回文子串是s[i]到s[j]（#前面）和s[p]到s[q]（#后面），那么这两个子串一定相同
所以通过前缀函数的构造后面的字符串的prefix中的位置一定分别对应s[i]到s[j]，那么最后一个字符的prefix元素就是最长回文子串的长度

根据以上推论，代码就比较容易了

class Solution {
public:string shortestPalindrome(string s) {std::string reverse_s(s.rbegin(), s.rend());std::string extend_s = s + "#" + reverse_s;int *prefix = new int[extend_s.size()];treat_prefix(extend_s, prefix);/* 获取最长回文子串的长度，然后把后面多余的部分也添加到前面 */int max_palindrome_len = prefix[extend_s.size() - 1];std::string ans = s;while(max_palindrome_len < s.size()){ans = s[max_palindrome_len++] + ans;}delete []prefix;return ans;}private:void treat_prefix(std::string& extend_s, int *prefix){int l = 0;prefix[0] = 0;for(int i = 1; i < extend_s.size(); ++i){while(l > 0 && extend_s[i] != extend_s[l])l = prefix[l - 1];if(extend_s[i] == extend_s[l])++l;prefix[i] = l;}}
};

这道题主要就是利用KMP算法，算是个积累知识，处理回文字符串时多一种考虑的可能