最长回文子序列与最长回文子串

最长回文子序列与最长回文子串不同。

字符串的子串：一个字符串中连续的一段就是这个字符串的子串。

最长回文子串：就是字符串中最长的身为回文串的子串。

最长回文子序列不一定连续

最长回文子序列：

方法一：递归方法

str[0...n-1]是给定的字符串序列，长度为n，假设lps(0,n-1)表示序列str[0...n-1]的最长回文子序列的长度。

1.如果str的最后一个元素和第一个元素是相同的，则有：lps(0,n-1)=lps(1,n-2)+2；例如字符串序列“AABACACBA”，第一个元素和最后一个元素相同，其中lps(1,n-2)表示红色部分的最长回文子序列的长度；

2.如果str的最后一个元素和第一个元素是不相同的，则有：lps(0,n-1)=max(lps(1,n-1),lps(0,n-2))；例如字符串序列“ABACACB”，其中lps(1,n-1)表示去掉第一元素的子序列，lps(0,n-2)表示去掉最后一个元素的子序列。

#include<iostream>
#include<string>
#include<algorithm>
using namespace std;

//递归方法，求解最长回文子序列
int lps(char *str, int i, int j)
{
	if (i == j)
		return 1;	//只有一个元素，回文长度为1
	if (i > j) return 0;   //因为只计算序列str[i....j]

	//如果首尾相同
	if (str[i] == str[j])
		return lps(str, i + 1, j - 1) + 2;
	//如果首尾不同
	return max(lps(str, i, j - 1), lps(str, i + 1, j));
}

int main()
{
	char str[] = "cabbeaf";
	int n = strlen(str);
	int res = lps(str, 0, n - 1);
	cout << res<< endl;
	getchar();
	return 0;
}

方法二：动态规划

对任意字符串，如果头和尾相同，那么它的最长回文子序列一定是去头去尾之后的部分的最长回文子序列加上头和尾。如果头和尾不同，那么它的最长回文子序列是去头的部分的最长回文子序列和去尾的部分的最长回文子序列的较长的那一个。

设字符串为s，f(i,j)表示s[i..j]的最长回文子序列。 

状态转移方程如下： 

当i>j时，f(i,j)=0。 

当i=j时，f(i,j)=1。 

当i<j并且s[i]=s[j]时，f(i,j)=f(i+1,j-1)+2。 

当i<j并且s[i]≠s[j]时，f(i,j)=max( f(i,j-1), f(i+1,j) )。 

由于f(i,j)依赖i+1，所以循环计算的时候，第一维必须倒过来计算，从s.length()-1到0。 

最后，s的最长回文子序列长度为f(0, s.length()-1)。

代码：

（时间复杂度O（n^2）），空间复杂度O（n^2））

#include <iostream>  
#include <cstring>  
using namespace std;  

#define MAX 100  
#define max(a,b) (a)>(b)?(a):(b)  

int f[MAX][MAX]={0};  

void LPS_Length(char *s,int len)
{
	for (int i=len-1;i>=0;i--)  
	{  
		//	当i=j时，f(i,j)==1
		f[i][i]=1;  
		for (int j=i+1;j<len;j++)
		{
			//	当i<j并且s[i]=s[j]时，f(i,j)=f(i+1,j-1)+2
			if (s[i]==s[j])			
				f[i][j]=f[i+1][j-1]+2;
			else		
				//	当i<j并且s[i]≠s[j]时，f(i,j)=max( f(i,j-1), f(i+1,j) )
				f[i][j]=max(f[i][j-1],f[i+1][j]);  
		}
	}  
	
}
int main()  
{  
		char *str="abcffggcbda";//字符串长度不能超过100
		int len=strlen(str);
		LPS_Length(str,len);
		cout<<f[0][len-1]<<endl; //输出回文长序列度

	return 0;  
}

为进一步减小空间复杂度，我们发现计算第i行时只用到了第i+1行，这样我们便不需要n行，只需要2行即可。

起初先在第0行计算f[s.length()-1]，然后用第0行的结果计算f[s.length()-2]，再用第1行的结果计算f[s.length()-3]，以此类推。正在计算的那行设为flag，那么下一行就是1-flag。这种方法很巧妙。

当计算完成时，如果s.length()是奇数，则结果在第0行；如果是偶数，则结果在第1行。 

此空间复杂度为O(n)。

#include <iostream>  
#include <cstring>  
using namespace std;  

#define MAX 100  
#define max(a,b) (a)>(b)?(a):(b)  

int f[2][MAX]={0};  

void LPS_Length(char *s,int len)
{
	int flag=0;
	for (int i=len-1;i>=0;i--)  
	{  
		//	当i=j时，f(i,j)==1
		f[flag][i]=1;  
		for (int j=i+1;j<len;j++)//一个for循环是一行，从i到len
		{
			//	当i<j并且s[i]=s[j]时，f(i,j)=f(i+1,j-1)+2
			if (s[i]==s[j])			
				f[flag][j]=f[1-flag][j-1]+2;
			else		
				//	当i<j并且s[i]≠s[j]时，f(i,j)=max( f(i,j-1), f(i+1,j) )
				f[flag][j]=max(f[flag][j-1],f[1-flag][j]);  	
		}
		flag=1-flag;
	}  
	
}
int main()  
{  
		char *str="abcffgtmgcbda";//字符串长度不能超过100
		int len=strlen(str);
		LPS_Length(str,len);
		if(len%2 == 0)
			cout<<f[1][len-1]<<endl; //输出回文长序列度
		else
			cout<<f[0][len-1]<<endl;

	return 0;  
}