GFG App
Open App
Browser
Continue

# 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”

Recommended Practice

### 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 ` `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 ` `#include `   `// 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(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.

### 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 ` `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 ` `#include `   `// 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(N3) 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 ` `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 ` `#include ` `#include `   `// 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(N2). A nested traversal is needed.
Auxiliary Space: O(N2). 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 ` `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 ` `#include `   `// 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(N2), where N is the length of the input string
Auxiliary Space: O(1), No extra space used.

My Personal Notes arrow_drop_up