【PAT-A1040】Longest Symmetric String（DP or string hash）

【分析】

最长回文子串问题。有DP和字符串hash两种方法。

• 字符串hash

  • 先求出字符串hash数组H1[]，再将字符串反转，求出其字符串hash数组H2[].
  • 对回文子串长度分奇偶讨论：
    • 奇数时，枚举回文子串中心点i，二分回文子串半径k，找到最大的使子串str[i - k]~str[i + k]是回文子串的半径k。而判断子串str[i - k]~str[i + k]是回文子串的方法就是：比较str的子串str[i-k, i] 的hash值H1[i-k, i] 等于其反转串的子串[n-1-(i+k), n-1-i]的hash值H2[n-1-(i+k), n-1-i]。
    • 偶数时，枚举回文两个点的空隙点（具体可以用左端点下标i代替）二分回文子串半径k，找到最大的使子串str[i - k + 1]~str[i + k]是回文子串的半径k。而判断子串str[i - k + 1]~str[i + k]是回文子串的方法就是：比较str的子串str[i-k +1, i] 的hash值H1[i-k+1, i] 等于其反转串的子串[n-1-(i+k), n-1-(i+1)]的hash值H2[n-1-(i+k), n-1-(i+1)]。
    • 子串hash值可以由公式H[i-j] = (((H[j] - H[i-1])*powP[j-i+1]%mod)+mod)%mod

• 注意二分右边界。二分有边界应该为分界点i左右长度的较小值加1.至于为什么加这个1，是因为，二分时候，退出while的条件是l == r此时如果答案正好为可能的最大值，即左右长度的较小值，那么如果此时右边界没加1，返回的会是这个较小值-1。

• DP的方法

  • 这里DP的难点就是遍历顺序，需要从按照长度遍历。

【代码】

字符串hash法

#include <cstdio>
#include <string>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long LL;
const LL P = 10000019;
const LL MOD = 1000000007;
const LL maxn = 1010;
LL Pow[maxn], H1[maxn], H2[maxn];

void initP() {
	Pow[0] = 1;
	for (int i = 1; i < maxn; i++)
	{
		Pow[i] = (Pow[i - 1] * P) % MOD;
	}
}

void calH(LL H[], string& str) {
	H[0] = str[0];
	for (int i = 1; i < str.size(); i++)
	{
		H[i] = ((H[i - 1] * P) + str[i]) % MOD;
	}

}

int calSingleH(LL H[], LL i, LL j) {
	if (i==0)
	{
		return H[j];
	}
	return ((H[j] - H[i - 1] * Pow[j - i + 1]) % MOD + MOD) % MOD;
}

int binarySearch(int l, int r, int i, int len, bool isEven) {
	while (l < r) // 因为是找满足条件的最大半径值所以是找第一个不满足条件的.用<
	{
		int mid = (l + r) / 2;
		if (isEven) {
			int H1L = i - mid + 1, H1R = i, H2L = len - 1 - (i + mid), H2R = len - 1 - (i + 1);
			int hashL = calSingleH(H1, H1L, H1R);
			int hashR = calSingleH(H2, H2L, H2R);
			if (hashL == hashR) {
				l = mid + 1;
			}
			else
			{
				r = mid;
			}
			
		}
		else
		{
			int H1L = i - mid, H1R = i, H2L = len - 1 - (i + mid), H2R = len - 1 - i;
			int hashL = calSingleH(H1, H1L, H1R);
			int hashR = calSingleH(H2, H2L, H2R);
			if (hashL == hashR) {
				l = mid + 1;
			}
			else
			{
				r = mid;
			}
		}
	}
	return l - 1;
}

int main() {
	string str;
	getline(cin, str);
	initP();
	calH(H1, str);
	reverse(str.begin(), str.end());
	calH(H2, str);
	int maxk = 0;
	// 奇回文
	for (int i = 0; i < str.size(); i++)
	{
		int r = min(i, (int)str.size() - 1 - i);
		int k = binarySearch(0, r, i, str.size(), false);
		maxk = max(k * 2 + 1, maxk);
	}
	// 偶回文
	for (int i = 0; i < str.size(); i++)
	{
		int r = min(i + 1, (int)str.size() - 1 - i);
		int k = binarySearch(0, r, i, str.size(), true);
		maxk = max(k * 2, maxk);
	}
	printf("%d\n", maxk);
	return 0;
}

DP法

/*
DP法
dp[i][j]表示子串s[i,j]是否是回文子串,0表示否，1表示是
*/
#include <cstdio>
#include <string>
#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
const int maxn = 1010;
int dp[maxn][maxn];

int main() {
	memset(dp, 0, sizeof(dp));
	string str;
	getline(cin, str);
	int ans = 1;
	int len = str.length();
	for (int i = 0; i < len; i++)
	{
		dp[i][i] = 1;
		if (i < len - 1)
		{
			if (str[i] == str[i+1])
			{
				dp[i][i + 1] = 1;
				ans = 2;
			}
		}
	}

	for (int L = 3; L <= len; L++) // L子串长度，从3开始，1，2是边界
	{
		for (int i = 0; i + L - 1 < len; i++)
		{
			int j = i + L - 1;
			if (str[i] == str[j] && dp[i + 1][j - 1] == 1) {
				ans = L;
				dp[i][j] = 1;
			}
		}
	}
	cout << ans << endl;
	return 0;
}