Maximum length palindromic substring for every index such that it starts and ends at that index
Last Updated :
20 May, 2024
Given a string S, the task for every index of the string is to find the length of the longest palindromic substring that either starts or ends at that index.
Examples:
Input: S = "bababa"
Output: 5 5 3 3 5 5
Explanation:
Longest palindromic substring starting at index 0 is "babab". Therefore, length = 5
Longest palindromic substring starting at index 1 is "ababa". Therefore, length = 5
Longest palindromic substring ending at index 2 is "bab". Therefore, length = 3
Longest palindromic substring ending at index 3 is "aba". Therefore, length = 3
Longest palindromic substring ending at index 4 is "babab". Therefore, length = 5
Longest palindromic substring ending at index 5 is "ababa". Therefore, length = 5
Input: S = "aaa"
Output: 3 2 3
Explanation:
Longest palindromic substring starting at index 0 is "aaa". Therefore, length = 3
Longest palindromic substring starting at index 1 is "ab". Therefore, length = 2
Longest palindromic substring ending at index 3 is: "aaa". Therefore, length = 3
Approach: The idea to solve this problem is to traverse the string and for each index, check for the longest palindromic substring that can be formed with that index either as the starting index and the ending index of the palindromic substring. Follow the steps below to solve the problem:
- Initialize an array palLength[] to store the length of the longest palindromic substrings for each index.
- Traverse the string using a variable i and perform the following operations:
- Initialize a variable, say maxLength, to store the length of the longest palindromic substring for each index.
- Consider i to be the ending index of a palindromic substring and find the first index from j over the range [0, i - 1], such that S[j, i] is a palindrome. Update maxLength.
- Consider i as the starting index of a palindromic substring and find the last index from j over the range [N - 1, i + 1], such that S[i, j] is a palindrome. Update maxLength.
- Store the maximum length obtained by storing the value of maxLength in palLength[i].
- After completing the above steps, print the array palLength[] as the result.
Below is the implementation of the above approach:
C++
// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
// Function to return true if
// S[i...j] is a palindrome
bool isPalindrome(string S, int i, int j)
{
// Iterate until i < j
while (i < j) {
// If unequal character encountered
if (S[i] != S[j])
return false;
i++;
j--;
}
// Otherwise
return true;
}
// Function to find for every index,
// longest palindromic substrings
// starting or ending at that index
void printLongestPalindrome(string S, int N)
{
// Stores the maximum palindromic
// substring length for each index
int palLength[N];
// Traverse the string
for (int i = 0; i < N; i++) {
// Stores the maximum length
// of palindromic substring
int maxlength = 1;
// Consider that palindromic
// substring ends at index i
for (int j = 0; j < i; j++) {
// If current character is
// a valid starting index
if (S[j] == S[i]) {
// If S[i, j] is palindrome,
if (isPalindrome(S, j, i)) {
// Update the length of
// the longest palindrome
maxlength = i - j + 1;
break;
}
}
}
// Consider that palindromic
// substring starts at index i
for (int j = N - 1; j > i; j--) {
// If current character is
// a valid ending index
if (S[j] == S[i]) {
// If str[i, j] is palindrome
if (isPalindrome(S, i, j)) {
// Update the length of
// the longest palindrome
maxlength = max(j - i + 1, maxlength);
break;
}
}
}
// Update length of the longest
// palindromic substring for index i
palLength[i] = maxlength;
}
// Print the length of the
// longest palindromic substring
for (int i = 0; i < N; i++) {
cout << palLength[i] << " ";
}
}
// Driver Code
int main()
{
string S = "bababa";
int N = S.length();
printLongestPalindrome(S, N);
return 0;
}
// This code is contributed by Kingash.
// Java program for the above approach
class GFG {
// Function to find for every index,
// longest palindromic substrings
// starting or ending at that index
public static void printLongestPalindrome(String S,
int N)
{
// Stores the maximum palindromic
// substring length for each index
int palLength[] = new int[N];
// Traverse the string
for (int i = 0; i < N; i++) {
// Stores the maximum length
// of palindromic substring
int maxlength = 1;
// Consider that palindromic
// substring ends at index i
for (int j = 0; j < i; j++) {
// If current character is
// a valid starting index
if (S.charAt(j) == S.charAt(i)) {
// If S[i, j] is palindrome,
if (isPalindrome(S, j, i)) {
// Update the length of
// the longest palindrome
maxlength = i - j + 1;
break;
}
}
}
// Consider that palindromic
// substring starts at index i
for (int j = N - 1; j > i; j--) {
// If current character is
// a valid ending index
if (S.charAt(j) == S.charAt(i)) {
// If str[i, j] is palindrome
if (isPalindrome(S, i, j)) {
// Update the length of
// the longest palindrome
maxlength = Math.max(j - i + 1,
maxlength);
break;
}
}
}
// Update length of the longest
// palindromic substring for index i
palLength[i] = maxlength;
}
// Print the length of the
// longest palindromic substring
for (int i = 0; i < N; i++) {
System.out.print(palLength[i] + " ");
}
}
// Function to return true if
// S[i...j] is a palindrome
public static boolean isPalindrome(String S, int i,
int j)
{
// Iterate until i < j
while (i < j) {
// If unequal character encountered
if (S.charAt(i) != S.charAt(j))
return false;
i++;
j--;
}
// Otherwise
return true;
}
// Driver Code
public static void main(String[] args)
{
String S = "bababa";
int N = S.length();
printLongestPalindrome(S, N);
}
}
# Python program for the above approach
# Function to return true if
# S[i...j] is a palindrome
def isPalindrome(S, i, j):
# Iterate until i < j
while (i < j):
# If unequal character encountered
if (S[i] != S[j]):
return False
i += 1
j -= 1
# Otherwise
return True
# Function to find for every index,
# longest palindromic substrings
# starting or ending at that index
def printLongestPalindrome(S, N):
# Stores the maximum palindromic
# substring length for each index
palLength = [0 for i in range(N)]
# Traverse the string
for i in range(N):
# Stores the maximum length
# of palindromic substring
maxlength = 1
# Consider that palindromic
# substring ends at index i
for j in range(i):
# If current character is
# a valid starting index
if (S[j] == S[i]):
# If S[i, j] is palindrome,
if (isPalindrome(S, j, i)):
# Update the length of
# the longest palindrome
maxlength = i - j + 1
break
# Consider that palindromic
# substring starts at index i
j = N-1
while(j > i):
# If current character is
# a valid ending index
if (S[j] == S[i]):
# If str[i, j] is palindrome
if (isPalindrome(S, i, j)):
# Update the length of
# the longest palindrome
maxlength = max(j - i + 1, maxlength)
break
j -= 1
# Update length of the longest
# palindromic substring for index i
palLength[i] = maxlength
# Print the length of the
# longest palindromic substring
for i in range(N):
print(palLength[i], end=" ")
# Driver Code
if __name__ == '__main__':
S = "bababa"
N = len(S)
printLongestPalindrome(S, N)
# This code is contributed by SURENDRA_GANGWAR.
// C# program for the above approach
using System;
class GFG {
// Function to return true if
// S[i...j] is a palindrome
static bool isPalindrome(string S, int i, int j)
{
// Iterate until i < j
while (i < j) {
// If unequal character encountered
if (S[i] != S[j])
return false;
i++;
j--;
}
// Otherwise
return true;
}
// Function to find for every index,
// longest palindromic substrings
// starting or ending at that index
static void printLongestPalindrome(string S, int N)
{
// Stores the maximum palindromic
// substring length for each index
int[] palLength = new int[N];
// Traverse the string
for (int i = 0; i < N; i++) {
// Stores the maximum length
// of palindromic substring
int maxlength = 1;
// Consider that palindromic
// substring ends at index i
for (int j = 0; j < i; j++) {
// If current character is
// a valid starting index
if (S[j] == S[i]) {
// If S[i, j] is palindrome,
if ((isPalindrome(S, j, i)) != false) {
// Update the length of
// the longest palindrome
maxlength = i - j + 1;
break;
}
}
}
// Consider that palindromic
// substring starts at index i
for (int j = N - 1; j > i; j--) {
// If current character is
// a valid ending index
if (S[j] == S[i]) {
// If str[i, j] is palindrome
if (isPalindrome(S, i, j)) {
// Update the length of
// the longest palindrome
maxlength = Math.Max(j - i + 1,
maxlength);
break;
}
}
}
// Update length of the longest
// palindromic substring for index i
palLength[i] = maxlength;
}
// Print the length of the
// longest palindromic substring
for (int i = 0; i < N; i++) {
Console.Write(palLength[i] + " ");
}
}
// Driver Code
static public void Main()
{
string S = "bababa";
int N = S.Length;
printLongestPalindrome(S, N);
}
}
// This code is contributed by code_hunt.
<script>
// JavaScript program for the above approach
// Function to return true if
// S[i...j] is a palindrome
function isPalindrome(S, i, j) {
// Iterate until i < j
while (i < j) {
// If unequal character encountered
if (S[i] !== S[j]) return false;
i++;
j--;
}
// Otherwise
return true;
}
// Function to find for every index,
// longest palindromic substrings
// starting or ending at that index
function printLongestPalindrome(S, N) {
// Stores the maximum palindromic
// substring length for each index
var palLength = new Array(N);
// Traverse the string
for (var i = 0; i < N; i++) {
// Stores the maximum length
// of palindromic substring
var maxlength = 1;
// Consider that palindromic
// substring ends at index i
for (var j = 0; j < i; j++) {
// If current character is
// a valid starting index
if (S[j] === S[i]) {
// If S[i, j] is palindrome,
if (isPalindrome(S, j, i) !== false) {
// Update the length of
// the longest palindrome
maxlength = i - j + 1;
break;
}
}
}
// Consider that palindromic
// substring starts at index i
for (var j = N - 1; j > i; j--) {
// If current character is
// a valid ending index
if (S[j] === S[i]) {
// If str[i, j] is palindrome
if (isPalindrome(S, i, j)) {
// Update the length of
// the longest palindrome
maxlength = Math.max(j - i + 1, maxlength);
break;
}
}
}
// Update length of the longest
// palindromic substring for index i
palLength[i] = maxlength;
}
// Print the length of the
// longest palindromic substring
for (var i = 0; i < N; i++) {
document.write(palLength[i] + " ");
}
}
// Driver Code
var S = "bababa";
var N = S.length;
printLongestPalindrome(S, N);
</script>
Time Complexity: O(N3)
Auxiliary Space: O(1)
Approach using Dynamic Programming
The task requires us to find the maximum length of palindromic substrings that either start or end at every index in a given string, S. We can achieve this by optimizing the detection of palindromic substrings using a dynamic programming approach which significantly reduces time complexity compared to the naive method.
Steps:
- Construct the dp table where dp[i][j] will be True if S[i] to S[j] is a palindrome.
- This is initialized by setting all single-character substrings as palindromes (dp[i][i] = True) and checking two-character substrings.
- Use the properties of palindromes to expand from each character and from each pair of identical characters to find longer palindromes, updating the results for each index appropriately.
Below is the implementation of above approach:
C++
#include <iostream>
#include <string>
#include <vector>
using namespace std;
vector<int>
print_longest_palindromic_substrings(const string& s)
{
int n = s.length();
if (n == 0)
return {};
// Initialize DP table with false values
vector<vector<bool> > dp(n, vector<bool>(n, false));
vector<int> longest(
n, 1); // Result array initialized with 1
// Every single character is a palindrome
for (int i = 0; i < n; ++i) {
dp[i][i] = true;
}
// Check for two-character palindromes
for (int i = 0; i < n - 1; ++i) {
if (s[i] == s[i + 1]) {
dp[i][i + 1] = true;
longest[i] = 2;
longest[i + 1] = 2;
}
}
// Check for palindromes longer than 2
for (int length = 3; length <= n; ++length) {
for (int i = 0; i <= n - length; ++i) {
int j = i + length - 1;
// Expand if the end characters are the same and
// the middle substring is a palindrome
if (s[i] == s[j] && dp[i + 1][j - 1]) {
dp[i][j] = true;
longest[i] = max(longest[i], j - i + 1);
longest[j] = max(longest[j], j - i + 1);
}
}
}
return longest;
}
int main()
{
string S = "bababa";
vector<int> result
= print_longest_palindromic_substrings(S);
for (int length : result) {
cout << length << " ";
}
cout << endl;
return 0;
}
import java.util.Arrays;
public class LongestPalindromicSubstrings {
public static void main(String[] args)
{
String S = "bababa";
int[] result = printLongestPalindromicSubstrings(S);
// Print the results
for (int length : result) {
System.out.print(length + " ");
}
System.out.println();
}
public static int[] printLongestPalindromicSubstrings(
String s)
{
int n = s.length();
if (n == 0)
return new int[0]; // Return an empty array if
// the input string is empty
// Initialize DP table with false values
boolean[][] dp = new boolean[n][n];
int[] longest
= new int[n]; // Result array initialized with 0
Arrays.fill(longest,
1); // Every single character is a
// palindrome of length 1
// Every single character is a palindrome
for (int i = 0; i < n; ++i) {
dp[i][i]
= true; // Single characters are palindromes
}
// Check for two-character palindromes
for (int i = 0; i < n - 1; ++i) {
if (s.charAt(i) == s.charAt(i + 1)) {
dp[i][i + 1]
= true; // Two consecutive same
// characters are palindromes
longest[i] = 2; // Update the result array
longest[i + 1] = 2;
}
}
// Check for palindromes longer than 2
for (int length = 3; length <= n; ++length) {
for (int i = 0; i <= n - length; ++i) {
int j = i + length - 1;
// Expand if the end characters are the same
// and the middle substring is a palindrome
if (s.charAt(i) == s.charAt(j)
&& dp[i + 1][j - 1]) {
dp[i][j] = true; // Mark this substring
// as a palindrome
longest[i] = Math.max(
longest[i],
j - i
+ 1); // Update the result array
longest[j]
= Math.max(longest[j], j - i + 1);
}
}
}
return longest;
}
}
def print_longest_palindromic_substrings(s):
n = len(s)
if n == 0:
return []
# Initialize DP table
dp = [[False] * n for _ in range(n)]
longest = [1] * n # Result array
# Every single character is a palindrome
for i in range(n):
dp[i][i] = True
# Check for two-character palindromes
for i in range(n - 1):
if s[i] == s[i + 1]:
dp[i][i + 1] = True
longest[i] = 2
longest[i + 1] = 2
# Check for palindromes longer than 2
for length in range(3, n + 1): # length of the palindrome
for i in range(n - length + 1):
j = i + length - 1
# Expand if the end characters are the same and the middle substring is
# a palindrome
if s[i] == s[j] and dp[i + 1][j - 1]:
dp[i][j] = True
longest[i] = max(longest[i], j - i + 1)
longest[j] = max(longest[j], j - i + 1)
return longest
# Example Usage
S = "bababa"
print(print_longest_palindromic_substrings(S))
function printLongestPalindromicSubstrings(s) {
const n = s.length;
if (n === 0) return []; // Return an empty array if the input string is empty
// Initialize DP table with false values
const dp = Array.from({ length: n }, () => Array(n).fill(false));
const longest = new Array(n).fill(1); // Result array initialized with 0
// Every single character is a palindrome
for (let i = 0; i < n; ++i) {
dp[i][i] = true; // Single characters are palindromes
}
// Check for two-character palindromes
for (let i = 0; i < n - 1; ++i) {
if (s[i] === s[i + 1]) {
dp[i][i + 1] = true; // Two consecutive same characters are palindromes
longest[i] = 2; // Update the result array
longest[i + 1] = 2;
}
}
// Check for palindromes longer than 2
for (let length = 3; length <= n; ++length) {
for (let i = 0; i <= n - length; ++i) {
const j = i + length - 1;
// Expand if the end characters are the same and the middle substring is a palindrome
if (s[i] === s[j] && dp[i + 1][j - 1]) {
dp[i][j] = true; // Mark this substring as a palindrome
longest[i] = Math.max(longest[i], j - i + 1); // Update the result array
longest[j] = Math.max(longest[j], j - i + 1);
}
}
}
return longest;
}
// Example usage
const S = "bababa";
const result = printLongestPalindromicSubstrings(S);
// Print the results
console.log(result.join(" "));
Time Complexity: O(N^2), where N is the length of the string. The time complexity comes from the need to fill out the DP table which checks all substrings.
Auxilary Space: O(N^2), required for the DP table that holds palindrome information for substrings.
Similar Reads
Maximum length palindromic substring such that it starts and ends with given char
Given a string str and a character ch, the task is to find the longest palindromic sub-string of str such that it starts and ends with the given character ch.Examples: Input: str = "lapqooqpqpl", ch = 'p' Output: 6 "pqooqp" is the maximum length palindromic sub-string that starts and ends with 'p'.I
7 min read
Maximum even length sub-string that is permutation of a palindrome
Given string str , the task is to find the maximum length of the sub-string of str that can be arranged into a Palindrome (i.e at least one of its permutation is a Palindrome). Note that the sub-string must be of even length. Examples: Input: str = "124565463" Output: 6 "456546" is the valid sub-str
9 min read
Minimum replacements such that no palindromic substring of length exceeding 1 is present in the given string
Given a string str consisting of lowercase characters, the task is to modify the string such that it does not contain any palindromic substring of length exceeding 1 by minimum replacement of characters. Examples: Input: str = �"Output: 4String can be modified to "bacbacb" by replacing 4 characters.
9 min read
Maximum length palindrome that can be created with characters in range L and R
Given a string str and Q queries. Each query consists of two numbers L and R. The task is to find the maximum length palindrome that can be created with characters in the range [L, R]. Examples: Input: str = "amim", Q[] = {{1, 4}, {3, 4} Output: 3 1 In range [1, 4], only two palindromes "mam" and "m
10 min read
Minimum length of substring whose rotation generates a palindromic substring
Given a string str, the task is to find the minimum length of substring required to rotate that generates a palindromic substring from the given string. Examples: Input: str = "abcbd" Output: 0 Explanation: No palindromic substring can be generated. There is no repeated character in the string. Inpu
7 min read
Number of positions where a letter can be inserted such that a string becomes palindrome
Given a string str, we need to find the no. of positions where a letter(lowercase) can be inserted so that string becomes a palindrome. Examples: Input : str = "abca" Output : possible palindromic strings: 1) acbca (at position 2) 2) abcba (at position 4) Hence, the output is 2. Input : str = "aaa"
11 min read
Check if a string contains a palindromic sub-string of even length
S is string containing only lowercase English alphabets. We need to find if there exists at least one palindromic sub-string whose length is even. Examples: Input : aassssOutput : YESInput : gfgOutput : NOApproach: Approach to solve this problem is to check all even-length substrings of the given st
8 min read
Convert s1 into a Palindrome such that s1 contains s2 as Substring
Given two strings s1 and s2, The task is to convert s1 into a palindrome such that s1 contains s2 as a substring in a minimum number of operations. In a single operation, we can replace any word of s1 with any character. If it is not possible to convert s1 such that it is a palindrome as well as con
9 min read
Maximize the minimum length of K palindromic Strings formed from given String
Given a string str of length N, and an integer K, the task is to form K different strings by choosing characters from the given string such that all the strings formed are palindrome and the length of the smallest string among the K strings is maximum possible. Examples: Input: str = "qrsprtps", K =
10 min read
Find a palindromic string B such that given String A is a subsequence of B
Given a string A . Find a string B , where B is a palindrome and A is a subsequence of B. A subsequence of a string is a string that can be derived from it by deleting some (not necessarily consecutive) characters without changing the order of the remaining characters. For example, "cotst" is a subs
6 min read