Given a string str, the task is to find the longest substring which is a palindrome.
Examples:
Input: str = “forgeeksskeegfor”
Output: “geeksskeeg”
Explanation: There are several possible palindromic substrings like “kssk”, “ss”, “eeksskee” etc. But the substring “geeksskeeg” is the longest among all.
Input: str = “Geeks”
Output: “ee”
Naive Approach for Longest Palindromic Substring:
Check each substring, if it is a palindrome or not and keep updating the longest palindromic substring found till now.
Follow the steps mentioned below to implement the idea:
- Generate all the substrings.
- For each substring, check if it is palindrome or not.
- If substring is Palindrome, then update the result on the basis of longest palindromic substring found till now.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
void printSubStr(string str, int low, int high)
{
for ( int i = low; i <= high; ++i)
cout << str[i];
}
int longestPalSubstr(string str)
{
int n = str.size();
int maxLength = 1, start = 0;
for ( int i = 0; i < str.length(); i++) {
for ( int j = i; j < str.length(); j++) {
int flag = 1;
for ( int k = 0; k < (j - i + 1) / 2; k++)
if (str[i + k] != str[j - k])
flag = 0;
if (flag && (j - i + 1) > maxLength) {
start = i;
maxLength = j - i + 1;
}
}
}
cout << "Longest palindrome substring is: " ;
printSubStr(str, start, start + maxLength - 1);
return maxLength;
}
int main()
{
string str = "forgeeksskeegfor" ;
cout << "\nLength is: " << longestPalSubstr(str);
return 0;
}
|
C
#include <stdio.h>
#include <string.h>
void printSubStr( const char * str, int low, int high)
{
for ( int i = low; i <= high; ++i)
printf ( "%c" , str[i]);
}
int longestPalSubstr( const char * str)
{
int n = strlen (str);
int maxLength = 1, start = 0;
for ( int i = 0; i < n; i++) {
for ( int j = i; j < n; j++) {
int flag = 1;
for ( int k = 0; k < (j - i + 1) / 2; k++)
if (str[i + k] != str[j - k])
flag = 0;
if (flag && (j - i + 1) > maxLength) {
start = i;
maxLength = j - i + 1;
}
}
}
printf ( "Longest palindrome substring is: " );
printSubStr(str, start, start + maxLength - 1);
printf ( "\n" );
return maxLength;
}
int main()
{
const char * str = "forgeeksskeegfor" ;
printf ( "Length is: %d\n" , longestPalSubstr(str));
return 0;
}
|
Java
import java.util.*;
class GFG {
static void printSubStr(String str, int low, int high)
{
for ( int i = low; i <= high; ++i)
System.out.print(str.charAt(i));
}
static int longestPalSubstr(String str)
{
int n = str.length();
int maxLength = 1 , start = 0 ;
for ( int i = 0 ; i < str.length(); i++) {
for ( int j = i; j < str.length(); j++) {
int flag = 1 ;
for ( int k = 0 ; k < (j - i + 1 ) / 2 ; k++)
if (str.charAt(i + k)
!= str.charAt(j - k))
flag = 0 ;
if (flag != 0 && (j - i + 1 ) > maxLength) {
start = i;
maxLength = j - i + 1 ;
}
}
}
System.out.print(
"Longest palindrome substring is: " );
printSubStr(str, start, start + maxLength - 1 );
return maxLength;
}
public static void main(String[] args)
{
String str = "forgeeksskeegfor" ;
System.out.print( "\nLength is: "
+ longestPalSubstr(str));
}
}
|
Python3
def printSubStr( str , low, high):
for i in range (low, high + 1 ):
print ( str [i], end = "")
def longestPalSubstr( str ):
n = len ( str )
maxLength = 1
start = 0
for i in range (n):
for j in range (i, n):
flag = 1
for k in range ( 0 , ((j - i) / / 2 ) + 1 ):
if ( str [i + k] ! = str [j - k]):
flag = 0
if (flag ! = 0 and (j - i + 1 ) > maxLength):
start = i
maxLength = j - i + 1
print ( "Longest palindrome substring is: " , end = "")
printSubStr( str , start, start + maxLength - 1 )
return maxLength
if __name__ = = '__main__' :
str = "forgeeksskeegfor"
print ( "\nLength is:" , longestPalSubstr( str ))
|
C#
using System;
class GFG {
static void printSubStr(String str, int low, int high)
{
for ( int i = low; i <= high; ++i)
Console.Write(str[i]);
}
static int longestPalSubstr(String str)
{
int n = str.Length;
int maxLength = 1, start = 0;
for ( int i = 0; i < str.Length; i++) {
for ( int j = i; j < str.Length; j++) {
int flag = 1;
for ( int k = 0; k < (j - i + 1) / 2; k++)
if (str[i + k] != str[j - k])
flag = 0;
if (flag != 0 && (j - i + 1) > maxLength) {
start = i;
maxLength = j - i + 1;
}
}
}
Console.Write( "Longest palindrome substring is: " );
printSubStr(str, start, start + maxLength - 1);
return maxLength;
}
public static void Main(String[] args)
{
String str = "forgeeksskeegfor" ;
Console.Write( "\nLength is: "
+ longestPalSubstr(str));
}
}
|
Javascript
function printSubStr(str,low,high)
{
for (let i = low; i <= high; ++i)
console.log(str[i]);
}
function longestPalSubstr(str)
{
let n = str.length;
let maxLength = 1, start = 0;
for (let i = 0; i < str.length; i++) {
for (let j = i; j < str.length; j++) {
let flag = 1;
for (let k = 0; k < (j - i + 1) / 2; k++)
if (str[i + k] != str[j - k])
flag = 0;
if (flag!=0 && (j - i + 1) > maxLength) {
start = i;
maxLength = j - i + 1;
}
}
}
console.log( "Longest palindrome substring is: " );
printSubStr(str, start, start + maxLength - 1);
return maxLength;
}
let str = "forgeeksskeegfor" ;
console.log( "Length is: "
+ longestPalSubstr(str));
|
Output
Longest palindrome substring is: geeksskeeg
Length is: 10
Complexity Analysis:
- Time complexity: O(N3). Three nested loops are needed to find the longest palindromic substring in this approach.
- Auxiliary complexity: O(1). As no extra space is needed.
The main idea behind the approach is that if we know the status (i.e., palindrome or not) of the substring ranging [i, j], we can find the status of the substring ranging [i-1, j+1] by only matching the character str[i-1] and str[j+1].
- If the substring from i to j is not a palindrome, then the substring from i-1 to j+1 will also not be a palindrome. Otherwise, it will be a palindrome only if str[i-1] and str[j+1] are the same.
Base on this fact, we can create a 2D table (say table[][] which stores status of substring str[i . . . j] ), and check for substrings with length from 1 to N. For each length find all the substrings starting from each character i and find if it is a palindrom or not using the above idea. The longest length for which a palindrome formed will be the required asnwer.
Illustration:
Follow the below illustration for a better understanding.
Consider the string “geeks“. Below is the structure of the table formed and from this, we can see that the longest substring is 2.

Table for the string “geeks”
Follow the steps mentioned below to implement the idea:
- Maintain a boolean table[N][N] that is filled in a bottom-up manner.
- Iterate for all possible lengths from 1 to N:
- For each length iterate from i = 0 to N-length:
- Find the end of the substring j = i+length-1.
- The value of table[i][j] is true, if the substring is palindrome, otherwise false.
- To calculate table[i][j], check the value of table[i+1][j-1]:
- if the value is true and str[i] is the same as str[j], then we make table[i][j] true.
- Otherwise, the value of table[i][j] is made false.
- We have to fill the table initially for substrings of length = 1 and length = 2.
- Update the longest palindrome accordingly whenever a new palindrome of greater length is found.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
void printSubStr(
string str, int low, int high)
{
for ( int i = low; i <= high; ++i)
cout << str[i];
}
int longestPalSubstr(string str)
{
int n = str.size();
bool table[n][n];
memset (table, 0, sizeof (table));
int maxLength = 1;
for ( int i = 0; i < n; ++i)
table[i][i] = true ;
int start = 0;
for ( int i = 0; i < n - 1; ++i) {
if (str[i] == str[i + 1]) {
table[i][i + 1] = true ;
start = i;
maxLength = 2;
}
}
for ( int k = 3; k <= n; ++k) {
for ( int i = 0; i < n - k + 1; ++i) {
int j = i + k - 1;
if (table[i + 1][j - 1] && str[i] == str[j]) {
table[i][j] = true ;
if (k > maxLength) {
start = i;
maxLength = k;
}
}
}
}
cout << "Longest palindrome substring is: " ;
printSubStr(str, start, start + maxLength - 1);
return maxLength;
}
int main()
{
string str = "forgeeksskeegfor" ;
cout << "\nLength is: "
<< longestPalSubstr(str);
return 0;
}
|
C
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
void printSubStr( const char * str, int low, int high)
{
for ( int i = low; i <= high; ++i)
printf ( "%c" , str[i]);
}
int longestPalSubstr( const char * str)
{
int n = strlen (str);
bool table[n][n];
memset (table, false , sizeof (table));
int maxLength = 1;
int start = 0;
for ( int i = 0; i < n; ++i)
table[i][i] = true ;
for ( int i = 0; i < n - 1; ++i) {
if (str[i] == str[i + 1]) {
table[i][i + 1] = true ;
start = i;
maxLength = 2;
}
}
for ( int k = 3; k <= n; ++k) {
for ( int i = 0; i < n - k + 1; ++i) {
int j = i + k - 1;
if (table[i + 1][j - 1] && str[i] == str[j]) {
table[i][j] = true ;
if (k > maxLength) {
start = i;
maxLength = k;
}
}
}
}
printf ( "Longest palindrome substring is: " );
printSubStr(str, start, start + maxLength - 1);
printf ( "\n" );
return maxLength;
}
int main()
{
const char * str = "forgeeksskeegfor" ;
printf ( "Length is: %d\n" , longestPalSubstr(str));
return 0;
}
|
Java
public class LongestPalinSubstring {
static void printSubStr(
String str, int low, int high)
{
System.out.println(
str.substring(
low, high + 1 ));
}
static int longestPalSubstr(String str)
{
int n = str.length();
boolean table[][] = new boolean [n][n];
int maxLength = 1 ;
for ( int i = 0 ; i < n; ++i)
table[i][i] = true ;
int start = 0 ;
for ( int i = 0 ; i < n - 1 ; ++i) {
if (str.charAt(i) == str.charAt(i + 1 )) {
table[i][i + 1 ] = true ;
start = i;
maxLength = 2 ;
}
}
for ( int k = 3 ; k <= n; ++k) {
for ( int i = 0 ; i < n - k + 1 ; ++i) {
int j = i + k - 1 ;
if (table[i + 1 ][j - 1 ]
&& str.charAt(i) == str.charAt(j)) {
table[i][j] = true ;
if (k > maxLength) {
start = i;
maxLength = k;
}
}
}
}
System.out.print( "Longest palindrome substring is: " );
printSubStr(str, start,
start + maxLength - 1 );
return maxLength;
}
public static void main(String[] args)
{
String str = "forgeeksskeegfor" ;
System.out.println( "Length is: " + longestPalSubstr(str));
}
}
|
Python3
import sys
def printSubStr(st, low, high):
print ((st[low: high + 1 ]))
def longestPalSubstr(st):
n = len (st)
table = [[ 0 for x in range (n)] for y
in range (n)]
maxLength = 1
i = 0
while (i < n):
table[i][i] = True
i = i + 1
start = 0
i = 0
while i < n - 1 :
if (st[i] = = st[i + 1 ]):
table[i][i + 1 ] = True
start = i
maxLength = 2
i = i + 1
k = 3
while k < = n:
i = 0
while i < (n - k + 1 ):
j = i + k - 1
if (table[i + 1 ][j - 1 ] and
st[i] = = st[j]):
table[i][j] = True
if (k > maxLength):
start = i
maxLength = k
i = i + 1
k = k + 1
print ( "Longest palindrome substring is: " ,end = "")
printSubStr(st, start, start + maxLength - 1 )
return maxLength
if __name__ = = '__main__' :
st = "forgeeksskeegfor"
l = longestPalSubstr(st)
print ( "Length is:" , l)
|
C#
using System;
class GFG {
static void printSubStr( string str, int low,
int high)
{
Console.WriteLine(str.Substring(low,
high - low + 1));
}
static int longestPalSubstr( string str)
{
int n = str.Length;
bool [, ] table = new bool [n, n];
int maxLength = 1;
for ( int i = 0; i < n; ++i)
table[i, i] = true ;
int start = 0;
for ( int i = 0; i < n - 1; ++i) {
if (str[i] == str[i + 1]) {
table[i, i + 1] = true ;
start = i;
maxLength = 2;
}
}
for ( int k = 3; k <= n; ++k) {
for ( int i = 0; i < n - k + 1; ++i) {
int j = i + k - 1;
if (table[i + 1, j - 1] && str[i] == str[j]) {
table[i, j] = true ;
if (k > maxLength) {
start = i;
maxLength = k;
}
}
}
}
Console.Write( "Longest palindrome substring is: " );
printSubStr(str, start, start + maxLength - 1);
return maxLength;
}
public static void Main( string [] args)
{
string str = "forgeeksskeegfor" ;
Console.WriteLine( "Length is: " + longestPalSubstr(str));
}
}
|
Javascript
function printSubStr(str,low,high)
{
console.log(str.substring(low, high + 1));
}
function longestPalSubstr(str)
{
let n = str.length;
let table = new Array(n);
for (let i = 0; i < n; i++)
{
table[i] = new Array(n);
}
let maxLength = 1;
for (let i = 0; i < n; ++i)
table[i][i] = true ;
let start = 0;
for (let i = 0; i < n - 1; ++i)
{
if (str[i] == str[i + 1])
{
table[i][i + 1] = true ;
start = i;
maxLength = 2;
}
}
for (let k = 3; k <= n; ++k) {
for (let i = 0; i < n - k + 1; ++i)
{
let j = i + k - 1;
if (table[i + 1][j - 1]
&& str[i] == str[j]) {
table[i][j] = true ;
if (k > maxLength) {
start = i;
maxLength = k;
}
}
}
}
console.log( "Longest palindrome substring is; " );
printSubStr(str, start,
start + maxLength - 1);
return maxLength;
}
let str = "forgeeksskeegfor" ;
console.log( "Length is: " + longestPalSubstr(str));
|
Output
Longest palindrome substring is: geeksskeeg
Length is: 10
Time complexity: O(N2). A nested traversal is needed.
Auxiliary Space: O(N2). A matrix of size N*N is needed to store the table.
Longest Palindromic Substring using Expansion from center:
The LPS is either of even length or odd length. So the idea is to traverse the input string and for each character check if this character can be the center of a palindromic substring of odd length or even length.
Follow the steps mentioned below to implement the idea:
- Use two pointers, low and hi, for the left and right end of the current palindromic substring being found.
- Then checks if the characters at str[low] and str[hi] are the same.
- If they are, it expands the substring to the left and right by decrementing low and incrementing hi.
- It continues this process until the characters at str[low] and str[hi] are unequal or until the indices are in bounds.
- If the length of the current palindromic substring becomes greater than the maximum length, it updates the maximum length.
Below is the implementation of the above idea.
C++
#include <bits/stdc++.h>
using namespace std;
void printSubStr(string str, int low, int high)
{
for ( int i = low; i <= high; ++i)
cout << str[i];
}
int longestPalSubstr(string s)
{
int n = s.length();
int start = 0, end = 1;
int low, hi;
for ( int i = 0; i < n; i++) {
low = i - 1;
hi = i;
while (low >= 0 && hi < n && s[low] == s[hi]) {
if (hi - low + 1 > end) {
start = low;
end = hi - low + 1;
}
low--;
hi++;
}
low = i - 1;
hi = i + 1;
while (low >= 0 && hi < n && s[low] == s[hi]) {
if (hi - low + 1 > end) {
start = low;
end = hi - low + 1;
}
low--;
hi++;
}
}
cout << "Longest palindrome substring is: " ;
printSubStr(s, start, start + end - 1);
return end;
}
int main()
{
string str = "forgeeksskeegfor" ;
cout << "\nLength is: " << longestPalSubstr(str);
return 0;
}
|
C
#include <stdio.h>
#include <string.h>
void printSubStr( char str[], int low, int high)
{
for ( int i = low; i <= high; ++i)
printf ( "%c" , str[i]);
}
int longestPalSubstr( char s[])
{
int n = strlen (s);
int start = 0, end = 1;
int low, hi;
for ( int i = 0; i < n; i++) {
low = i - 1;
hi = i;
while (low >= 0 && hi < n && s[low] == s[hi]) {
if (hi - low + 1 > end) {
start = low;
end = hi - low + 1;
}
low--;
hi++;
}
low = i - 1;
hi = i + 1;
while (low >= 0 && hi < n && s[low] == s[hi]) {
if (hi - low + 1 > end) {
start = low;
end = hi - low + 1;
}
low--;
hi++;
}
}
printf ( "Longest palindrome substring is: " );
printSubStr(s, start, start + end - 1);
return end;
}
int main()
{
char str[] = "forgeeksskeegfor" ;
printf ( "\nLength is: %d" , longestPalSubstr(str));
return 0;
}
|
Java
class LongestPalinSubstring {
static void printSubStr(String str, int low, int high) {
for ( int i = low; i <= high; ++i)
System.out.print(str.charAt(i));
System.out.println();
}
static int longestPalSubstr(String s) {
int n = s.length();
int start = 0 , end = 1 ;
int low, hi;
for ( int i = 0 ; i < n; i++) {
low = i - 1 ;
hi = i;
while (low >= 0 && hi < n && s.charAt(low) == s.charAt(hi)) {
if (hi - low + 1 > end) {
start = low;
end = hi - low + 1 ;
}
low--;
hi++;
}
low = i - 1 ;
hi = i + 1 ;
while (low >= 0 && hi < n && s.charAt(low) == s.charAt(hi)) {
if (hi - low + 1 > end) {
start = low;
end = hi - low + 1 ;
}
low--;
hi++;
}
}
System.out.print( "Longest palindrome substring is: " );
printSubStr(s, start, start + end - 1 );
return end;
}
public static void main(String[] args) {
String s = "forgeeksskeegfor" ;
int length = longestPalSubstr(s);
System.out.println( "Length: " + length);
}
}
|
Python3
def printSubStr(s, low, high):
for i in range (low, high + 1 ):
print (s[i], end = "")
print ()
def longestPalSubstr(s):
n = len (s)
start = 0
end = 1
for i in range (n):
low = i - 1
hi = i
while low > = 0 and hi < n and s[low] = = s[hi]:
if hi - low + 1 > end:
start = low
end = hi - low + 1
low - = 1
hi + = 1
low = i - 1
hi = i + 1
while low > = 0 and hi < n and s[low] = = s[hi]:
if hi - low + 1 > end:
start = low
end = hi - low + 1
low - = 1
hi + = 1
print ( "Longest palindrome substring is: " , end = "")
printSubStr(s, start, start + end - 1 )
return end
if __name__ = = '__main__' :
s = "forgeeksskeegfor"
length = longestPalSubstr(s)
print ( "Length:" , length)
|
C#
using System;
class GFG {
static void PrintSubStr( string s, int low, int high)
{
for ( int i = low; i <= high; i++) {
Console.Write(s[i]);
}
Console.WriteLine();
}
static int LongestPalSubstr( string s)
{
int n = s.Length;
int start = 0;
int end = 1;
for ( int i = 0; i < n; i++) {
int low = i - 1;
int hi = i;
while (low >= 0 && hi < n && s[low] == s[hi]) {
if (hi - low + 1 > end) {
start = low;
end = hi - low + 1;
}
low--;
hi++;
}
low = i - 1;
hi = i + 1;
while (low >= 0 && hi < n && s[low] == s[hi]) {
if (hi - low + 1 > end) {
start = low;
end = hi - low + 1;
}
low--;
hi++;
}
}
Console.Write( "Longest palindrome substring is: " );
PrintSubStr(s, start, start + end - 1);
return end;
}
static void Main()
{
string s = "forgeeksskeegfor" ;
int length = LongestPalSubstr(s);
Console.WriteLine( "Length: " + length);
}
}
|
Javascript
function printSubStr(str, low, high) {
for (let i = low; i <= high; ++i) {
console.log(str[i]);
}
}
function longestPalSubstr(s) {
const n = s.length;
let start = 0, end = 1;
let low, hi;
for (let i = 0; i < n; i++) {
low = i - 1;
hi = i;
while (low >= 0 && hi < n && s[low] === s[hi]) {
if (hi - low + 1 > end) {
start = low;
end = hi - low + 1;
}
low--;
hi++;
}
low = i - 1;
hi = i + 1;
while (low >= 0 && hi < n && s[low] === s[hi]) {
if (hi - low + 1 > end) {
start = low;
end = hi - low + 1;
}
low--;
hi++;
}
}
console.log( "Longest palindrome substring is: " );
printSubStr(s, start, start + end - 1);
return end;
}
const str = "forgeeksskeegfor" ;
console.log( "\nLength is: " + longestPalSubstr(str));
|
Output
Longest palindrome substring is: geeksskeeg
Length is: 10
Time complexity: O(N2), where N is the length of the input string
Auxiliary Space: O(1), No extra space used.
Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!
Last Updated :
11 Oct, 2023
Like Article
Save Article