LeetCode刷题日记5---最长的回文子串

题目

做这道题的时候一开始毫无头绪，后来想到是求最长子串，一个子串往外扩展直至最长，联想到动态规划，可以用dp求解。那么怎么扩展呢？只要目前这个子串满足回文，分别往两端各扩展1个字符，只要这两个字符相等，就满足新的扩展串是回文串。初始值呢？就是只有1个字符（都是回文串），2个字符（两字符相等才是回文串）。

动态规划

1.定义dp：令dp[i][j]的值表示字符串s 第i个字符到第j个字符组成的串 是否为 回文串，是就dp[i][j]=true，否则false

2.状态转移方程：dp[i][j]=dp[i+1][j-1]&&(s[i]==s[j])

3.初始值：dp[i][i]=true，dp[i][i+1]=(s[i]==s[i+1])

故要求的最长回文串即为dp[i][j]为true中（j-i+1）最大的那一个。

以下代码是我根据题解写的，但是百思不得其解的是在本地上测试点可以通过，但是提交后输入为“null”，debug也没整出来。。。不理解。。。

#include<stdio.h>
#include<string.h>
#define M 1001
char * longestPalindrome(char * s)
{
	int n=strlen(s);
	if(n<2)
	{
		return s;
	} 
	int dp[M][M]={0};
	int i=0;
	for(i=0;i<n;i++)//初值 
	{
		dp[i][i]=true;
	}
	int begin=0,maxlen=1;//记录子串的起始位置和长度 
	for(int L=2;L<=n;L++)//递推开始，先枚举字串长度 
	{
		for(i=0;i<n;i++)
		{
			int j=i+L-1;//字串末尾位置 
			if(j>=n)//右边界越界！！！ 
			{
				break;
			}
			if(s[i]==s[j])
			{
				if(j-i<3)
				{
					dp[i][j]=true;
				}
				else{
					dp[i][j]=dp[i+1][j-1];
				}
			}
			else{
				dp[i][j]=false;
			}
			//只要dp[i][j]==true,说明是回文串，记录其起点和长度 
			if(dp[i][j]&&j-i+1>maxlen) 
			{
				maxlen=j-i+1;
				begin=i;
			}
		}
	}
	char ans[1001]={0};
	i=begin;
	for(int j=0;j<maxlen;j++,i++)
	{
		ans[j]=s[i];
	}
	//printf("%s",ans);
	return ans;
} 
int main()
{
	char s[1001]={0};
	scanf("%s",s);
	char*ans=longestPalindrome(s);
	printf("%s",ans);
}

以下是官方题解：这里的L步长设定思想需要注意

#include <iostream>
#include <string>
#include <vector>

using namespace std;

class Solution {
public:
    string longestPalindrome(string s) {
        int n = s.size();
        if (n < 2) {
            return s;
        }

        int maxLen = 1;
        int begin = 0;
        // dp[i][j] 表示 s[i..j] 是否是回文串
        vector<vector<int>> dp(n, vector<int>(n));
        // 初始化：所有长度为 1 的子串都是回文串
        for (int i = 0; i < n; i++) {
            dp[i][i] = true;
        }
        // 递推开始
        // 先枚举子串长度
        for (int L = 2; L <= n; L++) {
            // 枚举左边界，左边界的上限设置可以宽松一些
            for (int i = 0; i < n; i++) {
                // 由 L 和 i 可以确定右边界，即 j - i + 1 = L 得
                int j = L + i - 1;
                // 如果右边界越界，就可以退出当前循环
                if (j >= n) {
                    break;
                }

                if (s[i] != s[j]) {
                    dp[i][j] = false;
                } else {
                    if (j - i < 3) {
                        dp[i][j] = true;
                    } else {
                        dp[i][j] = dp[i + 1][j - 1];
                    }
                }

                // 只要 dp[i][L] == true 成立，就表示子串 s[i..L] 是回文，此时记录回文长度和起始位置
                if (dp[i][j] && j - i + 1 > maxLen) {
                    maxLen = j - i + 1;
                    begin = i;
                }
            }
        }
        return s.substr(begin, maxLen);
    }
};

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

中心扩展算法

动态规划是从边界情况开始一步一步拓展直到目标状态的，它会遍历串s所有字符，把所有子串是否为回文串都标记一遍。而中心扩展算法，其实也是要把所有的状态都标记一遍，不过它不是从最小的问题到中问题再到大问题的承前启后式，它是枚举出每种边界情况，然后对每个边界情况扩展直到无法扩展为止，最后答案就是得到的这些子串中最长的那个。

而这里的边界情况，就是上面提到的字符数为1或2的情况。也就是说，对字符串s遍历，每次有两种扩展情况，记录其中最长的起始点和末尾坐标。

class Solution {
public:
    pair<int, int> expandAroundCenter(const string& s, int left, int right) {
        while (left >= 0 && right < s.size() && s[left] == s[right]) {
            --left;
            ++right;
        }
        return {left + 1, right - 1};
    }

    string longestPalindrome(string s) {
        int start = 0, end = 0;
        for (int i = 0; i < s.size(); ++i) {
            auto [left1, right1] = expandAroundCenter(s, i, i);
            auto [left2, right2] = expandAroundCenter(s, i, i + 1);
            if (right1 - left1 > end - start) {
                start = left1;
                end = right1;
            }
            if (right2 - left2 > end - start) {
                start = left2;
                end = right2;
            }
        }
        return s.substr(start, end - start + 1);
    }
};