Longest Palindromic Substring

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:

The simple approach is to check each substring whether the substring is a palindrome or not. But to optimize it a bit, check for the substrings with higher length first.

Follow the steps mentioned below to implement the idea:

• Generate substrings of the given string such that substrings having greater length will be generated first. 
• To do this, run a loop where the iterator ‘LEN’ will go from N to 1, where N is the length of the given string. 
  • Run a nested loop and fix an iterator ‘j’ that will point at the starting index of the substring. 
  • Get the substring from j to j + LEN. 
• If the substring is a palindrome, return the substring (as the substring will be of the longest length and minimum starting index).

Below is the implementation of the above approach:

C++

// A C++ solution for longest palindrome

#include <bits/stdc++.h>
using namespace std;

// Function to print a substring str[low..high]
void printSubStr(string str, int low, int high)
{
    for (int i = low; i <= high; ++i)
        cout << str[i];
}

// This function prints the longest palindrome substring
// It also returns the length of the longest palindrome
int longestPalSubstr(string str)
{
    // Get length of input string
    int n = str.size();

    // All substrings of length 1 are palindromes
    int maxLength = 1, start = 0;

    // Nested loop to mark start and end index
    for (int i = 0; i < str.length(); i++) {
        for (int j = i; j < str.length(); j++) {
            int flag = 1;

            // Check palindrome
            for (int k = 0; k < (j - i + 1) / 2; k++)
                if (str[i + k] != str[j - k])
                    flag = 0;

            // Palindrome
            if (flag && (j - i + 1) > maxLength) {
                start = i;
                maxLength = j - i + 1;
            }
        }
    }

    cout << "Longest palindrome substring is: ";
    printSubStr(str, start, start + maxLength - 1);

    // Return length of LPS
    return maxLength;
}

// Driver Code
int main()
{
    string str = "forgeeksskeegfor";
    cout << "\nLength is: " << longestPalSubstr(str);
    return 0;
}

C

#include <stdio.h>
#include <string.h>

// Function to print a substring str[low..high]
void printSubStr(const char* str, int low, int high)
{
    for (int i = low; i <= high; ++i)
        printf("%c", str[i]);
}

// This function prints the longest palindrome substring
// It also returns the length of the longest palindrome
int longestPalSubstr(const char* str)
{
    // Get length of input string
    int n = strlen(str);

    // All substrings of length 1 are palindromes
    int maxLength = 1, start = 0;

    // Nested loop to mark start and end index
    for (int i = 0; i < n; i++) {
        for (int j = i; j < n; j++) {
            int flag = 1;

            // Check palindrome
            for (int k = 0; k < (j - i + 1) / 2; k++)
                if (str[i + k] != str[j - k])
                    flag = 0;

            // Palindrome
            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 length of LPS
    return maxLength;
}

// Driver Code
int main()
{
    const char* str = "forgeeksskeegfor";
    printf("Length is: %d\n", longestPalSubstr(str));
    return 0;
}

Java

// A Java solution for longest palindrome

import java.util.*;

class GFG {

    // Function to print a subString str[low..high]
    static void printSubStr(String str, int low, int high)
    {
        for (int i = low; i <= high; ++i)
            System.out.print(str.charAt(i));
    }

    // This function prints the
    // longest palindrome subString
    // It also returns the length
    // of the longest palindrome
    static int longestPalSubstr(String str)
    {
        // Get length of input String
        int n = str.length();

        // All subStrings of length 1
        // are palindromes
        int maxLength = 1, start = 0;

        // Nested loop to mark start and end index
        for (int i = 0; i < str.length(); i++) {
            for (int j = i; j < str.length(); j++) {
                int flag = 1;

                // Check palindrome
                for (int k = 0; k < (j - i + 1) / 2; k++)
                    if (str.charAt(i + k)
                        != str.charAt(j - k))
                        flag = 0;

                // Palindrome
                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 length of LPS
        return maxLength;
    }

    // Driver Code
    public static void main(String[] args)
    {
        String str = "forgeeksskeegfor";
        System.out.print("\nLength is: "
                         + longestPalSubstr(str));
    }
}

// This code is contributed by shikhasingrajput

Python3

# A Python3 solution for longest palindrome


# Function to print a subString str[low..high]
def printSubStr(str, low, high):
    for i in range(low, high + 1):
        print(str[i], end="")


# This function prints the
# longest palindrome subString
# It also returns the length
# of the longest palindrome
def longestPalSubstr(str):

    # Get length of input String
    n = len(str)

    # All subStrings of length 1
    # are palindromes
    maxLength = 1
    start = 0

    # Nested loop to mark start
    # and end index
    for i in range(n):
        for j in range(i, n):
            flag = 1

            # Check palindrome
            for k in range(0, ((j - i) // 2) + 1):
                if (str[i + k] != str[j - k]):
                    flag = 0

            # Palindrome
            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 length of LPS
    return maxLength


# Driver Code
if __name__ == '__main__':

    str = "forgeeksskeegfor"
    print("\nLength is:", longestPalSubstr(str))

# This code is contributed by 29AjayKumar

C#

// A C# solution for longest palindrome
using System;

class GFG {

    // Function to print a subString str[low..high]
    static void printSubStr(String str, int low, int high)
    {
        for (int i = low; i <= high; ++i)
            Console.Write(str[i]);
    }

    // This function prints the
    // longest palindrome subString
    // It also returns the length
    // of the longest palindrome
    static int longestPalSubstr(String str)
    {
        // get length of input String
        int n = str.Length;

        // All subStrings of length 1
        // are palindromes
        int maxLength = 1, start = 0;

        // Nested loop to mark start and end index
        for (int i = 0; i < str.Length; i++) {
            for (int j = i; j < str.Length; j++) {
                int flag = 1;

                // Check palindrome
                for (int k = 0; k < (j - i + 1) / 2; k++)
                    if (str[i + k] != str[j - k])
                        flag = 0;

                // Palindrome
                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 length of LPS
        return maxLength;
    }

    // Driver Code
    public static void Main(String[] args)
    {
        String str = "forgeeksskeegfor";
        Console.Write("\nLength is: "
                      + longestPalSubstr(str));
    }
}

// This code is contributed by shikhasingrajput

Javascript

// A Javascript solution for longest palindrome

// Function to print a subString str[low..high]
function printSubStr(str,low,high)
{
    for (let i = low; i <= high; ++i)
        console.log(str[i]);
}

// This function prints the
// longest palindrome subString
// It also returns the length
// of the longest palindrome
function longestPalSubstr(str)
{
    // Get length of input String
    let n = str.length;

    // All subStrings of length 1
    // are palindromes
    let maxLength = 1, start = 0;

    // Nested loop to mark start and end index
    for (let i = 0; i < str.length; i++) {
        for (let j = i; j < str.length; j++) {
            let flag = 1;

            // Check palindrome
            for (let k = 0; k < (j - i + 1) / 2; k++)
                if (str[i + k] != str[j - k])
                    flag = 0;

            // Palindrome
            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 length of LPS
    return maxLength;
}

// Driver Code
let str = "forgeeksskeegfor";
console.log("Length is: "
         + longestPalSubstr(str));

// This code is contributed by rag2127

Output

Longest palindrome substring is: geeksskeeg
Length is: 10

Complexity Analysis:

• Time complexity: O(N³). Three nested loops are needed to find the longest palindromic substring in this approach.
• Auxiliary complexity: O(1). As no extra space is needed.

Longest Palindromic Substring by finding probable first and last of Palindrome:

The idea is to find the possible last character of a possible palindrome for each character of the string and check if that substring is a palindromic substring and update the length based on that.

Follow the steps mentioned below to implement the idea:

• First, run a loop for iterating every character. 
  • Then run a nested loop inside it to check if there is any other character similar to the current character. 
    • If it is, then it is possible that they both are the first and last characters of the longest substring. 
    • Store that substring and check whether that substring is the longest palindrome or not. 
    • If yes then we will store that substring and keep iterating.
• After the iterations are over, return the longest palindromic substring.

Below is the implementation of the above approach.

C++

// A C++ solution for longest palindrome

#include <bits/stdc++.h>
using namespace std;

// This function prints the
// longest palindrome substring
// It also returns the length
// of the longest palindrome
int longestPalSubstr(string str)
{
    // Stores Longest palindrome Substring
    string longest = "";
    int n = str.length();
    int j;

    // To store substring which we think can be a palindrome
    string subs = "";

    // To store reverse of substring we think can be palindrome
    string subsrev = "";

    for(int i = 0; i < n; i++){
        j = n-1;
        while(i < j){

            // Checking whether the character at i and j
            // are same.
            // If they are same then that substring can be LPS
            if((str[i] == str[j]) && (longest.length() < (j-i+1))){
               subs = str.substr(i,(j-i+1));
               subsrev = subs;
               reverse(subsrev.begin(), subsrev.end());
               if(subs == subsrev){
                  longest = subs;
               }
            }
            j--;
        }
    }

    // If no longest substring then we will return
    // first character
    if(longest.length() == 0){
        longest = str[0];
    }
    cout << "Longest palindrome substring is: " << longest;

    // Return length of LPS
    return longest.length();
}

// Driver Code
int main()
{
    string str = "forgeeksskeegfor";
    cout << "\nLength is: "
        << longestPalSubstr(str);
    return 0;
}

C

#include <stdio.h>
#include <string.h>

// Function to check if a substring is a palindrome
int isPalindrome(const char* str, int start, int end)
{
    while (start < end) {
        if (str[start] != str[end])
            return 0;
        start++;
        end--;
    }
    return 1;
}

// This function prints the longest palindrome substring
// It also returns the length of the longest palindrome
int longestPalSubstr(const char* str)
{
    // Stores the longest palindrome substring
    char longest[1000] = "";
    int n = strlen(str);
    int maxLength = 1;

    // Traverse all substrings
    for (int i = 0; i < n; i++) {
        for (int j = i; j < n; j++) {
            // Check if the substring is a palindrome
            if (isPalindrome(str, i, j)) {
                int length = j - i + 1;
                if (length > maxLength) {
                    maxLength = length;
                    strncpy(longest, str + i, maxLength);
                    longest[maxLength] = '\0';
                }
            }
        }
    }

    printf("Longest palindrome substring is: %s\n",
           longest);

    // Return length of LPS
    return maxLength;
}

// Driver Code
int main()
{
    const char* str = "forgeeksskeegfor";
    printf("Length is: %d\n", longestPalSubstr(str));
    return 0;
}

Java

// Java code to implement the above idea

import java.util.*;

class Main {

    // This function prints the
    // longest palindrome substring
    // It also returns the length
    // of the longest palindrome
    static int longestPalSubstr(String str)
    {
        // Stores Longest Palindrome Substring
        String longest = "";
        int n = str.length();
        int j;

        // To store substring which we think can be a
        // palindrome
        String subs = "";

        // To store reverse of substring we think can be
        // palindrome
        String subsrev = "";
        for (int i = 0; i < n; i++) {
            j = n - 1;
            while (i < j) {

                // Checking whether the character at i and j
                // are same.
                // If they are same then that
                // substring can be LPS
                if (str.charAt(i) == str.charAt(j)
                    && longest.length() < (j - i + 1)) {
                    subs = str.substring(i, j + 1);
                    subsrev = new StringBuilder(subs)
                                  .reverse()
                                  .toString();
                    if (subs.equals(subsrev)) {
                        longest = subs;
                    }
                }
                j--;
            }
        }

        // If no longest substring then we will return first
        // character
        if (longest.length() == 0) {
            longest = str.substring(0, 1);
        }
        System.out.println(
            "Longest palindrome substring is: " + longest);

        // Return length of LPS
        return longest.length();
    }

    // Driver Code
    public static void main(String[] args)
    {
        String str = "forgeeksskeegfor";
        System.out.println("Length is: "
                           + longestPalSubstr(str));
    }
}

Python3

# Python code for the above approach


# This function prints the
# longest palindrome substring
# It also returns the length
# of the longest palindrome
def longestPalSubstr(s):
    n = len(s)

    # Stores Longest palindrome Substring
    longest = ""
    j = 0

    # To store substring which we think can be a palindrome
    subs = ""

    # To store reverse of substring we think can be palindrome
    subsrev = ""
    for i in range(n):
        j = n-1
        while i < j:

            # Checking whether the character
            # at i and j are same.
            # If they are same then
            # that substring can be LPS
            if(s[i] == s[j] and len(longest) < (j-i+1)):
                subs = s[i:(j+1)]
                subsrev = subs[::-1]
                if(subs == subsrev):
                    longest = subs
            j -= 1

    # If no longest substring then we will
    # return first character
    if(len(longest) == 0):
        longest = s[0]
    print("Longest palindrome substring is: " + longest)

    # Return length of LPS
    return len(longest)


# Driver Code
if __name__ == '__main__':
    stri = "forgeeksskeegfor"
    print("Length is: " + str(longestPalSubstr(stri)))

# This code is contributed by lokeshpotta20.

C#

// A C# solution for longest palindrome

using System;
using System.Collections.Generic;

class GFG {

    // This function prints the
    // longest palindrome substring
    // It also returns the length
    // of the longest palindrome
    static int longestPalSubstr(string str)
    {
        // Stores Longest palindrome Substring
        string longest = "";
        int n = str.Length;
        int j;

        // To store substring which we think can be a
        // palindrome
        string subs = "";

        // To store reverse of substring we think can be
        // palindrome
        string subsrev = "";
        for (int i = 0; i < n; i++) {
            j = n - 1;
            while (i < j) {

                // Checking whether the character at i and j
                // are same. If they are same then that
                // substring can be LPS
                if ((str[i] == str[j])
                    && (longest.Length < (j - i + 1))) {
                    subs = str.Substring(i, (j - i + 1));
                    subsrev = subs;
                    char[] charArray
                        = subsrev.ToCharArray();

                    // Declaring an empty string
                    subsrev = String.Empty;

                    // Iterating the each character from
                    // right to left
                    for (int k = charArray.Length - 1;
                         k > -1; k--) {

                        // Append each character to the
                        // reversedstring.
                        subsrev += charArray[k];
                    }

                    // Reverse(subsrev.begin(),
                    // subsrev.end());
                    if (subs == subsrev) {
                        longest = subs;
                    }
                }
                j--;
            }
        }

        // If no longest substring then
        // we will return first character
        if (longest.Length == 0) {
            longest += str[0];
        }
        Console.WriteLine(
            "Longest palindrome substring is: " + longest);

        // Return length of LPS
        return longest.Length;
    }

    // Driver Code
    static public void Main()
    {
        string str = "forgeeksskeegfor";
        Console.Write("Length is: "
                      + longestPalSubstr(str));
    }
}

Javascript

// A javascript solution for longest palindrome

// This function prints the
// longest palindrome substring
// It also returns the length
// of the longest palindrome
function longestPalSubstr(str)
{
    // Stores Longest palindrome Substring
    let longest = "";
    let n = str.length;
    let j;

    // To store substring which we think can be a palindrome
    let subs = "";

    // To store reverse of substring we think can be palindrome
    let subsrev = "";
    for(let i = 0; i < n; i++){
        j = n-1;
        while(i < j){

            // Checking whether the character at i and j are same.
            // If they are same then that substring can be LPS
            if((str[i] == str[j]) && (longest.length < (j-i+1))){
               subs = str.substring(i,(j+1));
               subsrev = subs;
               subsrev=subsrev.split('').reverse().join('');
               if(subs == subsrev){
                  longest = subs;
               }
            }
            j--;
        }
    }
   // If no longest substring then we will return
   // first character
    if(longest.length == 0){
        longest = str[0];
    }
    console.log("Longest palindrome substring is: " + longest);

    // Return length of LPS
    return longest.length;
}

// Driver Code
let str = "forgeeksskeegfor";
console.log("Length is: "+ longestPalSubstr(str));

Output

Longest palindrome substring is: geeksskeeg
Length is: 10

Time Complexity: O(N³) because used 2 nested loops and a reverse function in 2nd nested loop.
Auxiliary Space – O(length of longest palindrome)  – To store answer, substring which we think can be palindrome and reverse of string which we think is a palindrome.

Dynamic Programming approach for Longest Palindromic Substring:

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++

// A C++ dynamic programming
// solution for longest palindrome

#include <bits/stdc++.h>
using namespace std;

// Function to print a substring
// str[low..high]
void printSubStr(
    string str, int low, int high)
{
    for (int i = low; i <= high; ++i)
        cout << str[i];
}

// This function prints the
// longest palindrome substring
// It also returns the length of
// the longest palindrome
int longestPalSubstr(string str)
{
    // Get length of input string
    int n = str.size();

    // table[i][j] will be false if substring
    // str[i..j] is not palindrome.
    // Else table[i][j] will be true
    bool table[n][n];

    memset(table, 0, sizeof(table));

    // All substrings of length 1
    // are palindromes
    int maxLength = 1;

    for (int i = 0; i < n; ++i)
        table[i][i] = true;

    // Check for sub-string of length 2.
    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;
        }
    }

    // Check for lengths greater than 2.
    // k is length of substring
    for (int k = 3; k <= n; ++k) {

        // Fix the starting index
        for (int i = 0; i < n - k + 1; ++i) {

            // Get the ending index of substring from
            // starting index i and length k
            int j = i + k - 1;

            // Checking for sub-string from ith index to
            // jth index if str[i+1] to str[j-1] is a
            // palindrome
            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 length of LPS
    return maxLength;
}

// Driver Code
int main()
{
    string str = "forgeeksskeegfor";
    cout << "\nLength is: "
         << longestPalSubstr(str);
    return 0;
}

C

#include <stdbool.h>
#include <stdio.h>
#include <string.h>

// Function to print a substring str[low..high]
void printSubStr(const char* str, int low, int high)
{
    for (int i = low; i <= high; ++i)
        printf("%c", str[i]);
}

// This function prints the longest palindrome substring
// It also returns the length of the longest palindrome
int longestPalSubstr(const char* str)
{
    // Get length of input string
    int n = strlen(str);

    // table[i][j] will be false if substring str[i..j] is
    // not palindrome. Else table[i][j] will be true
    bool table[n][n];

    memset(table, false, sizeof(table));

    // All substrings of length 1 are palindromes
    int maxLength = 1;
    int start = 0;

    for (int i = 0; i < n; ++i)
        table[i][i] = true;

    // Check for sub-string of length 2.
    for (int i = 0; i < n - 1; ++i) {
        if (str[i] == str[i + 1]) {
            table[i][i + 1] = true;
            start = i;
            maxLength = 2;
        }
    }

    // Check for lengths greater than 2.
    for (int k = 3; k <= n; ++k) {
        // Fix the starting index
        for (int i = 0; i < n - k + 1; ++i) {
            // Get the ending index of substring from
            // starting index i and length k
            int j = i + k - 1;

            // Checking for sub-string from ith index to jth
            // index if str[i+1] to str[j-1] is a palindrome
            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 length of LPS
    return maxLength;
}

// Driver Code
int main()
{
    const char* str = "forgeeksskeegfor";
    printf("Length is: %d\n", longestPalSubstr(str));
    return 0;
}

Java

// Java Solution

public class LongestPalinSubstring {

    // A utility function to print
    // a substring str[low..high]
    static void printSubStr(
        String str, int low, int high)
    {
        System.out.println(
            str.substring(
                low, high + 1));
    }

    // This function prints the longest
    // palindrome substring of str[].
    // It also returns the length of the
    // longest palindrome
    static int longestPalSubstr(String str)
    {
        // Get length of input string
        int n = str.length();

        // table[i][j] will be false if
        // substring str[i..j] is not palindrome.
        // Else table[i][j] will be true
        boolean table[][] = new boolean[n][n];

        // All substrings of length 1 are palindromes
        int maxLength = 1;
        for (int i = 0; i < n; ++i)
            table[i][i] = true;

        // Check for sub-string of length 2.
        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;
            }
        }

        // Check for lengths greater than 2.
        // k is length of substring
        for (int k = 3; k <= n; ++k) {

            // Fix the starting index
            for (int i = 0; i < n - k + 1; ++i) {

                // Get the ending index of substring from
                // starting index i and length k
                int j = i + k - 1;

                // Checking for sub-string from ith index to
                // jth index if str.charAt(i+1) to
                // str.charAt(j-1) is a palindrome
                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 length of LPS
        return maxLength;
    }

    // Driver code
    public static void main(String[] args)
    {
        String str = "forgeeksskeegfor";
        System.out.println("Length is: " + longestPalSubstr(str));
    }
}

// This code is contributed by Sumit Ghosh

Python3

# Python program

import sys


# A utility function to print a
# substring str[low..high]
def printSubStr(st, low, high):
    print ((st[low: high + 1]))


# This function prints the longest palindrome
# substring of st[]. It also returns the length
# of the longest palindrome
def longestPalSubstr(st):

    # Get length of input string
    n = len(st)

    # table[i][j] will be false if substring
    # str[i..j] is not palindrome. Else
    # table[i][j] will be true
    table = [[0 for x in range(n)] for y
             in range(n)]

    # All substrings of length 1 are
    # palindromes
    maxLength = 1
    i = 0
    while (i < n):
        table[i][i] = True
        i = i + 1

    # Check for sub-string of length 2.
    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

    # Check for lengths greater than 2.
    # k is length of substring
    k = 3
    while k <= n:

        # Fix the starting index
        i = 0
        while i < (n - k + 1):

            # Get the ending index of
            # substring from starting
            # index i and length k
            j = i + k - 1

            # Checking for sub-string from
            # ith index to jth index if
            # st[i + 1] to st[(j-1)] is a
            # palindrome
            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 length of LPS
    return maxLength


# Driver code
if __name__ == '__main__':
    st = "forgeeksskeegfor"
    l = longestPalSubstr(st)
    print("Length is:", l)

# This code is contributed by Nikita Tiwari.

C#

// C# code to implement the above idea

using System;

class GFG {

    // A utility function to print a
    // substring str[low...( high - (low+1))]
    static void printSubStr(string str, int low,
                            int high)
    {
        Console.WriteLine(str.Substring(low,
                                        high - low + 1));
    }

    // This function prints the longest
    // palindrome substring of str[].
    // It also returns the length of the
    // longest palindrome
    static int longestPalSubstr(string str)
    {
        // Get length of input string
        int n = str.Length;

        // Table[i, j] will be false if substring
        // str[i..j] is not palindrome. Else
        // table[i, j] will be true
        bool[, ] table = new bool[n, n];

        // All substrings of length 1 are palindromes
        int maxLength = 1;
        for (int i = 0; i < n; ++i)
            table[i, i] = true;

        // Check for sub-string of length 2.
        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;
            }
        }

        // Check for lengths greater than 2.
        // k is length of substring
        for (int k = 3; k <= n; ++k) {

            // Fix the starting index
            for (int i = 0; i < n - k + 1; ++i) {

                // Get the ending index of substring from
                // starting index i and length k
                int j = i + k - 1;

                // Checking for sub-string from ith index
                // to jth index if str.charAt(i+1) to
                // str.charAt(j-1) is a palindrome
                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 length of LPS
        return maxLength;
    }

    // Driver code
    public static void Main(string[] args)
    {
        string str = "forgeeksskeegfor";

        Console.WriteLine("Length is: " + longestPalSubstr(str));
    }
}

// This code is contributed by SoumikMondal

Javascript

// Javascript Solution

    // A utility function to print
    // a substring str[low..high]
   function printSubStr(str,low,high)
   {
           console.log(str.substring(low, high + 1));
   }

   // This function prints the longest
   // palindrome substring of str[].
   // It also returns the length of the
   // longest palindrome
   function longestPalSubstr(str)
   {
        // Get length of input string
        let n = str.length;

        // table[i][j] will be false if
        // substring str[i..j] is not palindrome.
        // Else table[i][j] will be true
        let table = new Array(n);
        for(let i = 0; i < n; i++)
        {
            table[i] = new Array(n);
        }

        // All substrings of length 1 are palindromes
        let maxLength = 1;
        for (let i = 0; i < n; ++i)
            table[i][i] = true;

        // Check for sub-string of length 2.
        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;
            }
        }

        // Check for lengths greater than 2.
        // k is length of substring
        for (let k = 3; k <= n; ++k) {

            // Fix the starting index
            for (let i = 0; i < n - k + 1; ++i)
            {

                // Get the ending index of substring from
                // starting index i and length k
                let j = i + k - 1;

                // Checking for sub-string from ith index to
                // jth index if str.charAt(i+1) to
                // str.charAt(j-1) is a palindrome
                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 length of LPS
        return maxLength;
   }

   // Driver code
   let str = "forgeeksskeegfor";
   console.log("Length is: " + longestPalSubstr(str));

// This code is contributed by avanitrachhadiya2155

Output

Longest palindrome substring is: geeksskeeg
Length is: 10

Time complexity: O(N²). A nested traversal is needed.
Auxiliary Space: O(N²). A matrix of size N*N is needed to store the table.

Expansion from center approach for Longest Palindromic Substring:

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:

• To do this, we need 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++

// C++ code to implement the above idea

#include <bits/stdc++.h>
using namespace std;

// Function to print a substring str[low..high]
void printSubStr(string str, int low, int high)
{
    for (int i = low; i <= high; ++i)
        cout << str[i];
}

// Function to find the longest palindromic substring
int longestPalSubstr(string s)
{
    int n = s.length();
    int start = 0, end = 1;
    int low, hi;

    // Traverse the input string
    for (int i = 0; i < n; i++) {

        // Find longest palindromic substring of even size
        low = i - 1;
        hi = i;

        // Expand substring while it is palindrome
        // and in bounds
        while (low >= 0 && hi < n && s[low] == s[hi]) {

            // Update maximum length and starting index
            if (hi - low + 1 > end) {
                start = low;
                end = hi - low + 1;
            }
            low--;
            hi++;
        }

        // Find longest palindromic substring of odd size
        low = i - 1;
        hi = i + 1;

        // Expand substring while it is palindrome
        // and in bounds
        while (low >= 0 && hi < n && s[low] == s[hi]) {

            // Update maximum length and starting index
            if (hi - low + 1 > end) {
                start = low;
                end = hi - low + 1;

                low--;
                hi++;
            }
        }
    }

    // Print the longest palindromic substring
    cout << "Longest palindrome substring is: ";
    printSubStr(s, start, start + end - 1);

    // Return output length
    return end;
}

// Driver code
int main()
{
    string str = "forgeeksskeegfor";

    // Function call
    cout << "\nLength is: " << longestPalSubstr(str);
    return 0;
}

// This code is contributed by Tapesh(tapeshdua420)

C

#include <stdio.h>
#include <string.h>

// Function to print a substring str[low..high]
void printSubStr(const char* str, int low, int high)
{
    for (int i = low; i <= high; ++i)
        printf("%c", str[i]);
}

// Function to find the longest palindromic substring
int longestPalSubstr(const char* s)
{
    int n = strlen(s);
    int start = 0, end = 1;
    int low, hi;

    // Traverse the input string
    for (int i = 0; i < n; i++) {

        // Find longest palindromic substring of even size
        low = i - 1;
        hi = i;

        // Expand substring while it is palindrome
        // and in bounds
        while (low >= 0 && hi < n && s[low] == s[hi]) {

            // Update maximum length and starting index
            if (hi - low + 1 > end) {
                start = low;
                end = hi - low + 1;
            }
            low--;
            hi++;
        }

        // Find longest palindromic substring of odd size
        low = i - 1;
        hi = i + 1;

        // Expand substring while it is palindrome
        // and in bounds
        while (low >= 0 && hi < n && s[low] == s[hi]) {

            // Update maximum length and starting index
            if (hi - low + 1 > end) {
                start = low;
                end = hi - low + 1;

                low--;
                hi++;
            }
        }
    }

    // Print the longest palindromic substring
    printf("Longest palindrome substring is: ");
    printSubStr(s, start, start + end - 1);
    printf("\n");

    // Return output length
    return end;
}

// Driver code
int main()
{
    const char* str = "forgeeksskeegfor";

    // Function call
    printf("Length is: %d\n", longestPalSubstr(str));
    return 0;
}

Output

Longest palindrome substring is: geeksskeeg
Length is: 10

Time complexity: O(N²), where N is the length of the input string
Auxiliary Space: O(1), No extra space used.