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 = 5Input: 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++ 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>
|
5 5 3 3 5 5
Time Complexity: O(N3)
Auxiliary Space: O(1)