您的位置:首页 > 其它

每天一道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
相关文章推荐