# [longest palindrome substring of leetcode Hot 100]

Time：2021-3-5

The first question of new year’s brush is as follows:

Give you a string s and find the longest palindrome substring in S.

Example 1:

Output: “bab”
Explanation: “ABA” is also the answer to the question.
Example 2:

Enter: S = “CBBD”
Output: “BB”
Example 3:

Input: S = “a”
Output: “a”
Example 4:

Enter: S = “AC”
Output: “a”

Tips:

1 <= s.length <= 1000
S consists only of numbers and English letters (uppercase and / or lowercase)

Source: leetcode

Initial idea:

The initial idea is to expand each character to the left and right, cycle all the characters, and finally find the longest palindrome string.But I feel that the time complexity of this method is too high, so I don’t think about it. Alas, I’m not confident.

The answer is very detailed. There are three methods. The third one is not mentioned. It’s a bit complicated. The first one is the center expansion algorithm, which is similar to the original sub path

``````class Solution {
public:
pair getLongest(string & s,int left,int right)
{/ * note that this is the while loop, which will continue to expand outward until the longest palindrome string corresponding to the current character is found. */
While (left > = 0 & & right / * I'm not familiar with the usage of pair, so I haven't thought of using it like this*/
return {left+1,right-1};
}
string longestPalindrome(string s) {
Int start = 0, end = 0; / * here, the for loop iterates through each character*/
For (int i = 0; I / * I feel very confused. Why do I call getlong function twice? I simply understand it as two cases: odd length palindrome string and even length palindrome string. */
auto [left1,right1]=getLongest(s,i,i);
auto [left2,right2]=getLongest(s,i,i+1);
if(right1-left1>end-start)
{
start=left1;
end=right1;
}
if(right2-left2>end-start)
{
start=left2;
end=right2;
}
}/ * returns the longest palindrome string. The answer is not unique*/
return s.substr(start,end-start+1);
}
};``````

The second method introduced in the answer is dynamic programming. Look at the code directly

``````class Solution {
public:
string longestPalindrome(string s) {
Vector < vector < int > > DP (n, vector < int > (n)); string strreturn =; / * from length 1 to s.size (), be careful not to be misled by 0*/
For (int len = 0; len / * characters of each length are traversed and assigned*/
For (int, I = 0; I / * corresponds to the character itself*/
if(len==0)
{
dp[i][i]=1;
}/ * length 1*/
else if(len==1)
{
dp[i][i+len]=s[i]==s[i+len];
}/ * others*/
else
{
dp[i][i+len]=dp[i+1][i+len-1]&&(s[i]==s[i+len]);
}
if(dp[i][i+len]&&len+1>strReturn.size())
{
strReturn=s.substr(i,len+1);
}
}
}
return strReturn;
}
};``````

The time and space complexity of the two algorithms are compared as follows

Time complexity and space complexity

Center expansion algorithm:O（n*n）                  O（1）

Dynamic planning:O（n*n）　　　　　O(n*n)

## Case study of stack SQL optimization: implicit conversion

Data stack is a cloud native station data platform PAAS. We have an interesting open source project on GitHub and gitee: flinkx. Flinkx is a unified data synchronization tool based on Flink, which can collect both static data and real-time data. It is a global, heterogeneous, batch flow integrated data synchronization engine. If you like, […]