每天一道LeetCode-----最长回文子串/序列,从头开始的最长回文子串长度
2017-10-17 21:52
645 查看
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; else break; } --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算法,算是个积累知识,处理回文字符串时多一种考虑的可能
相关文章推荐
- 每天一道LeetCode-----计算最长的元素连续序列长度
- 每天一道LeetCode-----计算两个序列最长的公共子序列长度
- 每天一道LeetCode-----计算给定序列中所有长度为k的滑动窗的最大值集合
- 每天一道LeetCode-----最长无重复子串
- manacher算法_求最长回文子串长度
- 每天一道LeetCode-----数组序列,每个元素的值表示最多可以向后跳多远,计算最少跳多少次可以到达末尾
- python实现求最长回文子串长度
- 【C】动态规划--最大连续子序列和/最长不下降子序列/最长公共子序列/最长回文子串/DAG最长路
- 最长回文子串 leetcode 05 DP解法
- 找工作知识储备(2)---数组字符串那些经典算法:最大子序列和,最长递增子序列,最长公共子串,最长公共子序列,字符串编辑距离,最长不重复子串,最长回文子串
- 最长回文序列(返回长度)
- Longest Palindromic Substring 在一个字符串里找最长回文子串@LeetCode
- 数组字符串那些经典算法:最大子序列和,最长递增子序列,最长公共子串,最长公共子序列,字符串编辑距离,最长不重复子串,最长回文子串 (转)
- 最长回文子序列以及最长回文子串
- ] 找工作知识储备(2)---数组字符串那些经典算法:最大子序列和,最长递增子序列,最长公共子串,最长公共子序列,字符串编辑距离,最长不重复子串,最长回文子串
- 每天一道LeetCode-----找到序列中第一个没有出现的正整数,要求时间复杂度是O(n),空间复杂度是O(1)
- 最长公共子串、最长公共子序列、最长回文子串、模式匹配、最大子序列--字符串问题整理
- 数组字符串那些经典算法:最大子序列和,最长递增子序列,最长公共子串,最长公共子序列,字符串编辑距离,最长不重复子串,最长回文子串
- LeetCodeOJ_5_m_Longest Palindromic Substring(最长回文子串)
- 【LeetCode004-005算法/编程练习C++】--两个数组的中间数,找出最长回文子串