Longest Palindromic Substring | Set 2

• Difficulty Level : Medium
• Last Updated : 13 Jun, 2022

Given a string, find the longest substring which is a palindrome.
For Example:

```Input: Given string :"forgeeksskeegfor",
Output: "geeksskeeg".

Input: Given string :"Geeks",
Output: "ee".```

Very Common mistake :-

Wrong Approach:

Some people will be tempted to come up with a O(n) time complexity quick solution, which is unfortunately flawed (however can be corrected easily):

(i)Reverse S and  and store it in S’.
(ii)Find the longest common substring between S and S’  which must also be the longest palindromic substring.

This seemed to work, letâ€™s see some examples below.

For example, S = “caba” then  S’ = “abac”.

The longest common substring between S and S’ is “aba”, which is the answer.

Letâ€™s try another example: S = “abacdfgdcaba” then S’ = “abacdgfdcaba”.

The longest common substring between S and S’ is “abacd”. Clearly, this is not a valid palindrome.

Correct Approach:

We could see that the longest common substring method fails when there exists a reversed copy of a non-palindromic substring in some other part of S. To rectify this, each time we find a longest common substring candidate, we check if the substringâ€™s indices are the same as the reversed substringâ€™s original indices. If it is, then we attempt to update the longest palindrome found so far; if not, we skip this and find the next candidate.

This gives us an O(n^2) Dynamic Programming solution which uses O(n^2) space (could be improved to use O(n) space).

Dyanamic programming Approach: Dynamic programming solution is already discussed here in the previous post. The time complexity of the Dynamic Programming based solution is O(n^2) and it requires O(n^2) extra space. We can find the longest palindrome substring( LPS ) in (n^2) time with O(1) extra space.

The algorithm below is very simple and easy to understand. The idea is to Fix a center and expand in both directions for longer palindromes and keep track of the longest palindrome seen so far.

ALGO:

1. Maintain a variable ‘ maxLength = 1 ‘ (for storing LPS length) and ‘ start =0 ‘ (for storing starting index of LPS ).
2. The idea is very simple, we will traverse through the entire string with i=0 to i<(length of string).
1. while traversing, initialize ‘lowand ‘highpointer such that low= i-1 and high= i+1.
2. keep incrementing ‘high’ until str[high]==str[i] .
3. similarly keep decrementing ‘low’ until str[low]==str[i].
4. finally we will keep incrementing ‘high’ and decrementing ‘low’ until str[low]==str[high].
5. calculate length=high-low-1, if length > maxLength then maxLength = length and start = low+1 .
3. Print the LPS and return maxLength.

C++

 `// A O(n^2) time and O(1) space program to``// find the longest palindromic substring``// easy to understand as compared to previous version.``#include ``using` `namespace` `std;` `// A utility function to print``// a substring str[low..high]``// This function prints the``// longest palindrome substring (LPS)``// of str[]. It also returns the``// length of the longest palindrome``int` `longestPalSubstr(string str)``{``    ``int` `n = str.size(); ``// calculating size of string``    ``if` `(n < 2)``        ``return` `n; ``// if string is empty then size will be 0.``                  ``// if n==1 then, answer will be 1(single``                  ``// character will always palindrome)` `    ``int` `maxLength = 1,start=0;``    ``int` `low, high;``    ``for` `(``int` `i = 0; i < n; i++) {``        ``low = i - 1;``        ``high = i + 1;``        ``while` `( high < n && str[high] == str[i]) ``//increment 'high'                                  ``            ``high++;``      ` `        ``while` `( low >= 0 && str[low] == str[i]) ``// decrement 'low'                   ``            ``low--;``      ` `        ``while` `(low >= 0 && high < n && str[low] == str[high]){``              ``low--;``            ``high++;``        ``}` `        ``int` `length = high - low - 1;``        ``if` `(maxLength < length) {``            ``maxLength = length;``              ``start=low+1;``        ``}``    ``}``    ` `      ``cout<<``"Longest palindrome substring is: "``;``      ``cout<

C

 `// A O(n^2) time and O(1) space``// program to find the longest``// palindromic substring``#include ``#include ` `// A utility function to print``// a substring str[low..high]``void` `printSubStr(``char``* str, ``int` `low, ``int` `high)``{``    ``for` `(``int` `i = low; i <= high; ++i)``        ``printf``(``"%c"``, str[i]);``}` `// This function prints the longest``// palindrome substring (LPS)``// of str[]. It also returns the``// length of the longest palindrome``int` `longestPalSubstr(``char``* str)``{``    ``int` `n = ``strlen``(str); ``// calculating size of string``    ``if` `(n < 2)``        ``return` `n; ``// if string is empty then size will be 0.``                  ``// if n==1 then, answer will be 1(single``                  ``// character will always palindrome)` `    ``int` `maxLength = 1,start=0;``    ``int` `low, high;``    ``for` `(``int` `i = 0; i < n; i++) {``        ``low = i - 1;``        ``high = i + 1;``        ``while` `( high < n && str[high] == str[i]) ``//increment 'high'                                  ``            ``high++;``      ` `        ``while` `( low >= 0 && str[low] == str[i]) ``// decrement 'low'                   ``            ``low--;``      ` `        ``while` `(low >= 0 && high < n && str[low] == str[high]){``              ``low--; ``// decrement low``            ``high++; ``// increment high``        ``}` `        ``int` `length = high - low - 1;``        ``if` `(maxLength < length) {``            ``maxLength = length;``              ``start=low+1;``        ``}``    ``}``    ``printf``(``"Longest palindrome substring is: "``);``      ``printSubStr(str,start,start+maxLength-1);``    ``return` `maxLength;``}` `// Driver program to test above functions``int` `main()``{``    ``char` `str[] = ``"forgeeksskeegfor"``;``    ``printf``(``"\nLength is: %d"``, longestPalSubstr(str));``    ``return` `0;``}``// This is code is contributed by saurabh yadav`

Java

 `// Java implementation of O(n^2)``// time and O(1) space method``// to find the longest palindromic substring``public` `class` `LongestPalinSubstring {``  ` `    ``// This function prints the``    ``// longest palindrome substring``    ``// (LPS) of str[]. It also``    ``// returns the length of the``    ``// longest palindrome``    ``static` `int` `longestPalSubstr(String str)``    ``{``        ``int` `n = str.length(); ``// calculcharAting size of string``        ``if` `(n < ``2``)``            ``return` `n; ``// if string is empty then size will be 0.``                  ``// if n==1 then, answer will be 1(single``                  ``// character will always palindrome)` `        ``int` `maxLength = ``1``,start=``0``;``        ``int` `low, high;``        ``for` `(``int` `i = ``0``; i < n; i++) {``            ``low = i - ``1``;``            ``high = i + ``1``;``            ``while` `( high < n && str.charAt(high) == str.charAt(i)) ``//increment 'high'                                  ``                ``high++;``      ` `            ``while` `( low >= ``0` `&& str.charAt(low) == str.charAt(i)) ``// decrement 'low'                   ``                ``low--;``      ` `            ``while` `(low >= ``0` `&& high < n && str.charAt(low) == str.charAt(high) ){``                  ``low--;``                ``high++;``        ``}` `        ``int` `length = high - low - ``1``;``        ``if` `(maxLength < length){``            ``maxLength = length;``            ``start=low+``1``;``        ``}``    ``}   ``    ``System.out.print(``"Longest palindrome substring is: "``);``    ``System.out.println(str.substring(start, start + maxLength ));``    ``return` `maxLength;``      ` ` ``}` `    ``// Driver program to test above function``    ``public` `static` `void` `main(String[] args)``    ``{` `        ``String str = ``"forgeeksskeegfor"``;``        ``System.out.println(``"Length is: "``                           ``+ longestPalSubstr(str));``    ``}``}``// This is code is contributed by saurabh yadav`

Python3

 `# A O(n ^ 2) time and O(1) space program to find the``# longest palindromic substring` `# This function prints the longest palindrome substring (LPS)``# of str[]. It also returns the length of the longest palindrome`  `def` `longestPalSubstr(string):``    ``n ``=` `len``(string) ``# calculating size of string``    ``if` `(n < ``2``):``        ``return` `n ``# if string is empty then size will be 0.``                  ``# if n==1 then, answer will be 1(single``                  ``# character will always palindrome)``    ``start``=``0``    ``maxLength ``=` `1``    ``for` `i ``in` `range``(n):``        ``low ``=` `i ``-` `1``        ``high ``=` `i ``+` `1``        ``while` `(high < n ``and` `string[high] ``=``=` `string[i] ):                              ``            ``high``=``high``+``1``      ` `        ``while` `(low >``=` `0` `and` `string[low] ``=``=` `string[i] ):                ``            ``low``=``low``-``1``      ` `        ``while` `(low >``=` `0` `and` `high < n ``and` `string[low] ``=``=` `string[high] ):``          ``low``=``low``-``1``          ``high``=``high``+``1``        ` `    ` `        ``length ``=` `high ``-` `low ``-` `1``        ``if` `(maxLength < length):``            ``maxLength ``=` `length``            ``start``=``low``+``1``            ` `    ``print` `(``"Longest palindrome substring is:"``,end``=``" "``)``    ``print` `(string[start:start ``+` `maxLength])``    ` `    ``return` `maxLength``    ` `# Driver program to test above functions``string ``=` `(``"forgeeksskeegfor"``)``print``(``"Length is: "` `+` `str``(longestPalSubstr(string)))` `#This is code is contributed by saurabh yadav`

C#

 `// C# implementation of O(n^2) time``// and O(1) space method to find the``// longest palindromic substring``using` `System;` `class` `GFG {` `    ``// This function prints the longest``    ``// palindrome substring (LPS) of str[].``    ``// It also returns the length of the``    ``// longest palindrome``    ``public` `static` `int` `longestPalSubstr(``string` `str)``    ``{``        ``int` `n = str.Length; ``// calculcharAting size of string``        ``if` `(n < 2)``            ``return` `n; ``// if string is empty then size will be 0.``                  ``// if n==1 then, answer will be 1(single``                  ``// character will always palindrome)` `        ``int` `maxLength = 1,start=0;``        ``int` `low, high;``        ``for` `(``int` `i = 0; i < n; i++) {``            ``low = i - 1;``            ``high = i + 1;``            ``while` `( high < n && str[high] == str[i] ) ``//increment 'high'                                  ``                ``high++;``      ` `            ``while` `( low >= 0 && str[low] == str[i]) ``// decrement 'low'                   ``                ``low--;``      ` `            ``while` `(low >= 0 && high < n && str[low] == str[high] ){``                  ``low--;``                ``high++;``        ``}` `        ``int` `length = high - low - 1;``        ``if` `(maxLength < length){``            ``maxLength = length;``            ``start=low+1;``        ``}``    ``}   ``    ``Console.Write(``"Longest palindrome substring is: "``);``    ``Console.WriteLine(str.Substring(start, maxLength));``    ``return` `maxLength;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main(``string``[] args)``    ``{``        ``string` `str = ``"forgeeksskeegfor"``;``        ``Console.WriteLine(``"Length is: "``                          ``+ longestPalSubstr(str));``    ``}``}` `// This is code is contributed by saurabh yadav`

Javascript

 ``

Output:

```Longest palindrome substring is: geeksskeeg
Length is: 10```

Complexity Analysis:

• Time complexity: O(n^2), where n is the length of the input string.
Outer Loop that traverse through entire string, and Inner Loop that is used to expend from i .
• Auxiliary Space: O(1).
No extra space is needed.