(PAT Advanced)1040.Longest Symmetric String (字符串+动态规划) C++

原题：https://pintia.cn/problem-sets/994805342720868352/problems/994805446102073344

Given a string, you are supposed to output the length of the longest symmetric sub-string. For example, given Is PAT&TAP symmetric?, the longest symmetric sub-string is s PAT&TAP s, hence you must output 11.

Input Specification:
Each input file contains one test case which gives a non-empty string of length no more than 1000.

Output Specification:
For each test case, simply print the maximum length in a line.

Sample Input:
Is PAT&TAP symmetric?

Sample Output:
11

题目大意
输入一个字符串，判断其中最长的回文子串长度。

题目分析

方法1

假设数组 $dp[i][j]$ 表示字符串 $s[i]$ 到 $s[j]$ 间的字符串是否为回文串，取值为0或1，则我们有如下动态递推方程：

• 当 $i==j$ 时，有 $dp[i][j]=1$，此时长度为1
• 当 $j=i+1$时，有 $dp[i][j]=(s[i]==s[j])$，此时长度为2
• 当 $s[i]==s[j]$ 时，则 $dp[i][j]=dp[i+1][j-1]$
• 当 $s[i]̸=s[j]$ 时，则 $dp[i][j]=0$

具体进行递推的时候，我们可以设定间隔长度 L 从1到字符串的长度len， 然后 下标 $i$ 从 0 到 len - 1，每次判断 $i$ 到 $i+L-1$ 这段字符子串是否是回文串。

/* 1040 Longest Symmetric String (25 分) */
// 动态规划，最长回文串
#include<string>
#include<iostream>

using namespace std;
#define MAXLEN 1010
int dp[MAXLEN][MAXLEN];

int main() {
	string s;
	fill(dp[0], dp[0] + MAXLEN * MAXLEN, 0);
	getline(cin, s);
	int len = s.length();
	int i, j, ans = 1;
	// 从1开始暴力搜索
	for (int L = 1; L <= len; L++) {
		for (i = 0; i + L - 1 < len; i++) {
			j = i + L - 1;
			if (s[i] == s[j]) {
				if (i == j) 
					dp[i][j] = 1;
				else if (i + 1 == j && i < len - 1) {
					dp[i][j] = 1;
					ans = 2;
				}
				else if (dp[i + 1][j - 1]) {
					dp[i][j] = 1;
					ans = L;
				}
			}
		}
	}
	printf("%d\n", ans);

	system("pause");
	return 0;
}

即我们在填写二维动态递推数组**dp[][]**时，实际是一个上三角矩阵，且从间隔为3开始，每个位置的元素都与其左下方的元素有关，开始递推。

方法2
我们可以将字符串str进行翻转后得到字符串rev，然后计算str和rev的最长公共连续子串的长度，具体细节参照这篇博客。

/* 1040 Longest Symmetric String (25 分) */
// 最长公共子序列
#include<string>
#include<iostream>

using namespace std;

const int MAXLEN = 1010;
string str, rev;
int dp[MAXLEN][MAXLEN];
int DEBUG = 0;

string reverse(string s) {
	// 翻转字符串
	int len = s.length();
	for (int i = 0; i <= (len - 1) / 2; i++) {
		char tmp = s[i];
		s[i] = s[len - 1 - i];
		s[len - 1 - i] = tmp;
	}
	return s;
}
// 最长连续公共子序列
int LCS(string a, string b) {
	int lena = a.length();
	int lenb = b.length();
	// 初始化
	int i, j;
	for (i = 0; i < lena; i++) dp[i][0] = 0;
	for (i = 0; i < lenb; i++) dp[0][i] = 0;
	// 递推
	int maxlen = 0;
	for (i = 1; i <= lena; i++) {
		for (j = 1; j <= lenb; j++) {
			if (a[i - 1] == b[j - 1]) dp[i][j] = dp[i - 1][j - 1] + 1; // 接上前面的
			else dp[i][j] = 0; // 重新开始
			if (dp[i][j] > maxlen) maxlen = dp[i][j];
		}
	}
	return maxlen;
}
int main() {
	fill(dp[0], dp[0] + MAXLEN*MAXLEN, -1);
	getline(cin, str);
	rev = reverse(str);// 翻转字符串
	cout << LCS(str, rev) << endl;
	system("pause");
	return 0;
}

复杂度均为$O(n^2)$。