Skip to content
Related Articles
Open in App
Not now

Related Articles

Count maximum-length palindromes in a String

Improve Article
Save Article
  • Difficulty Level : Hard
  • Last Updated : 24 Nov, 2022
Improve Article
Save Article

Given a string, count how many maximum-length palindromes are present. (It need not be a substring)

Examples: 

Input : str = "ababa"
Output: 2
Explanation : 
palindromes of maximum of lengths are  :
 "ababa", "baaab" 

Input : str = "ababab"
Output: 4
Explanation : 
palindromes of maximum of lengths are  :
 "ababa", "baaab", "abbba", "babab"

Approach A palindrome can be represented as “str + t + reverse(str)”

Note: “t” is empty for even length palindromic strings 

Calculate in how many ways “str” can be made and then multiply with “t” (number of single characters left out).
Let ci be the number of occurrences of a character in the string. Consider the following cases: 

  1. If ci is even. Then half of every maximum palindrome will contain exactly letters fi = ci / 2. 
  2. If ci is odd. Then half of every maximum palindrome will contain exactly letters fi = (ci – 1)/ 2.

Let k be the number of odd ci. If k=0, the length of the maximum palindrome will be even; otherwise it will be odd and there will be exactly k possible middle letters i.e., we can set this letter to the middle of the palindrome.
The number of permutations of n objects with n1 identical objects of type 1, n2 identical objects of type 2, and n3 identical objects of type 3 is n! / (n1! * n2! * n3!)
So here we have total number of characters as fa+fb+fa+…….+fy+fz . So number of permutation is (fa+fb+fa+…….+fy+fz)! / fa! fb!…fy!fz!.
Now If K is not 0, it’s obvious that the answer is k * (fa+fb+fa+…….+fy+fz+)! / fa! fb!…fy!fz!

Below is the implementation of the above.

C++




// C++ implementation for counting
// maximum length palindromes
#include <bits/stdc++.h>
using namespace std;
 
// factorial of a number
int fact(int n)
{
    int ans = 1;
    for (int i = 1; i <= n; i++)   
        ans = ans * i;
    return (ans);
}
 
// function to count maximum length palindromes.
int numberOfPossiblePalindrome(string str, int n)
{  
    // Count number of occurrence
    // of a charterer in the string
    unordered_map<char, int> mp;
    for (int i = 0; i < n; i++)
        mp[str[i]]++;
 
    int k = 0;  // Count of singles
    int num = 0;  // numerator of result
    int den = 1;  // denominator of result
    int fi; 
    for (auto it = mp.begin(); it != mp.end(); ++it)
    {
        // if frequency is even
        // fi = ci / 2
        if (it->second % 2 == 0)
            fi = it->second / 2;
         
        // if frequency is odd
        // fi = ci - 1 / 2.
        else
        {
            fi = (it->second - 1) / 2;
            k++;
        }
 
        // sum of all frequencies
        num = num + fi;
         
        // product of factorial of
        // every frequency
        den = den * fact(fi);
    }
     
    // if all character are unique
    // so there will be no palindrome,
    // so if num != 0 then only we are
    // finding the factorial
    if (num != 0)
        num = fact(num);
         
    int ans = num / den;
     
    if (k != 0)
    {
        // k are the single
        // elements that can be
        // placed in middle
        ans = ans * k;
    }
     
    return (ans);
}
 
// Driver program
int main()
{
    char str[] = "ababab";
    int n = strlen(str);
    cout << numberOfPossiblePalindrome(str, n);
    return 0;
}

Java




// Java implementation for counting
// maximum length palindromes
import java.util.*;
 
class GFG
{
 
// factorial of a number
static int fact(int n)
{
    int ans = 1;
    for (int i = 1; i <= n; i++)
        ans = ans * i;
    return (ans);
}
 
// function to count maximum length palindromes.
static int numberOfPossiblePalindrome(String str, int n)
{
    // Count number of occurrence
    // of a charterer in the string
    Map<Character,Integer> mp = new HashMap<>();
    for (int i = 0; i < n; i++)
        mp.put( str.charAt(i),mp.get( str.charAt(i))==null?
                1:mp.get( str.charAt(i))+1);
 
    int k = 0; // Count of singles
    int num = 0; // numerator of result
    int den = 1; // denominator of result
    int fi;
    for (Map.Entry<Character,Integer> it : mp.entrySet())
    {
        // if frequency is even
        // fi = ci / 2
        if (it.getValue() % 2 == 0)
            fi = it.getValue() / 2;
         
        // if frequency is odd
        // fi = ci - 1 / 2.
        else
        {
            fi = (it.getValue() - 1) / 2;
            k++;
        }
 
        // sum of all frequencies
        num = num + fi;
         
        // product of factorial of
        // every frequency
        den = den * fact(fi);
    }
     
    // if all character are unique
    // so there will be no palindrome,
    // so if num != 0 then only we are
    // finding the factorial
    if (num != 0)
        num = fact(num);
         
    int ans = num / den;
     
    if (k != 0)
    {
        // k are the single
        // elements that can be
        // placed in middle
        ans = ans * k;
    }
     
    return (ans);
}
 
// Driver code
public static void main(String[] args)
{
    String str = "ababab";
    int n = str.length();
    System.out.println(numberOfPossiblePalindrome(str, n));
}
}
 
// This code is contributed by Princi Singh

Python3




# Python3 implementation for counting
# maximum length palindromes
import math as mt
 
# factorial of a number
def fact(n):
    ans = 1
    for i in range(1, n + 1):
        ans = ans * i
    return (ans)
 
# function to count maximum length palindromes.
def numberOfPossiblePalindrome(string, n):
     
    # Count number of occurrence
    # of a charterer in the string
    mp = dict()
    for i in range(n):
        if string[i] in mp.keys():
            mp[string[i]] += 1
        else:
            mp[string[i]] = 1
 
    k = 0 # Count of singles
    num = 0 # numerator of result
    den = 1 # denominator of result
    fi = 0
    for it in mp:
     
        # if frequency is even
        # fi = ci / 2
        if (mp[it] % 2 == 0):
            fi = mp[it] // 2
         
        # if frequency is odd
        # fi = ci - 1 / 2.
        else:
         
            fi = (mp[it] - 1) // 2
            k += 1
 
        # sum of all frequencies
        num = num + fi
         
        # product of factorial of
        # every frequency
        den = den * fact(fi)
     
    # if all character are unique
    # so there will be no palindrome,
    # so if num != 0 then only we are
    # finding the factorial
    if (num != 0):
        num = fact(num)
         
    ans = num //den
     
    if (k != 0):
     
        # k are the single
        # elements that can be
        # placed in middle
        ans = ans * k
     
    return (ans)
 
# Driver Code
string = "ababab"
n = len(string)
print(numberOfPossiblePalindrome(string, n))
 
# This code is contributed by
# Mohit kumar 29

C#




// C# implementation for counting
// maximum length palindromes
using System;
using System.Collections.Generic;
     
class GFG
{
 
// factorial of a number
static int fact(int n)
{
    int ans = 1;
    for (int i = 1; i <= n; i++)
        ans = ans * i;
    return (ans);
}
 
// function to count maximum length palindromes.
static int numberOfPossiblePalindrome(String str, int n)
{
    // Count number of occurrence
    // of a charterer in the string
    Dictionary<char,int> mp = new Dictionary<char,int>();
    for (int i = 0 ; i < n; i++)
    {
        if(mp.ContainsKey(str[i]))
        {
            var val = mp[str[i]];
            mp.Remove(str[i]);
            mp.Add(str[i], val + 1);
        }
        else
        {
            mp.Add(str[i], 1);
        }
    }
 
    int k = 0; // Count of singles
    int num = 0; // numerator of result
    int den = 1; // denominator of result
    int fi;
    foreach(KeyValuePair<char, int> it in mp)
    {
        // if frequency is even
        // fi = ci / 2
        if (it.Value % 2 == 0)
            fi = it.Value / 2;
         
        // if frequency is odd
        // fi = ci - 1 / 2.
        else
        {
            fi = (it.Value - 1) / 2;
            k++;
        }
 
        // sum of all frequencies
        num = num + fi;
         
        // product of factorial of
        // every frequency
        den = den * fact(fi);
    }
     
    // if all character are unique
    // so there will be no palindrome,
    // so if num != 0 then only we are
    // finding the factorial
    if (num != 0)
        num = fact(num);
         
    int ans = num / den;
     
    if (k != 0)
    {
        // k are the single
        // elements that can be
        // placed in middle
        ans = ans * k;
    }
     
    return (ans);
}
 
// Driver code
public static void Main(String[] args)
{
    String str = "ababab";
    int n = str.Length;
    Console.WriteLine(numberOfPossiblePalindrome(str, n));
}
}
 
// This code is contributed by 29AjayKumar

Javascript




<script>
 
// JavaScript implementation for counting
// maximum length palindromes
     
    // factorial of a number
    function fact(n)
    {
        let ans = 1;
    for (let i = 1; i <= n; i++)
        ans = ans * i;
    return (ans);
    }
 
// function to count maximum length palindromes.
function numberOfPossiblePalindrome(str,n)
{
    // Count number of occurrence
    // of a charterer in the string
    let mp = new Map();
    for (let i = 0; i < n; i++)
        mp.set( str[i],mp.get( str[i])==null?
                1:mp.get( str[i])+1);
   
    let k = 0; // Count of singles
    let num = 0; // numerator of result
    let den = 1; // denominator of result
    let fi;
    for (let [key, value] of mp.entries())
    {
        // if frequency is even
        // fi = ci / 2
        if (value % 2 == 0)
            fi = value / 2;
           
        // if frequency is odd
        // fi = ci - 1 / 2.
        else
        {
            fi = (value - 1) / 2;
            k++;
        }
   
        // sum of all frequencies
        num = num + fi;
           
        // product of factorial of
        // every frequency
        den = den * fact(fi);
    }
       
    // if all character are unique
    // so there will be no palindrome,
    // so if num != 0 then only we are
    // finding the factorial
    if (num != 0)
        num = fact(num);
           
    let ans = Math.floor(num / den);
       
    if (k != 0)
    {
        // k are the single
        // elements that can be
        // placed in middle
        ans = ans * k;
    }
       
    return (ans);
}
 
// Driver code
let str = "ababab";
let n = str.length;
document.write(numberOfPossiblePalindrome(str, n));
     
 
// This code is contributed by unknown2108
 
</script>

Output

4

Time Complexity: O(n), where n is the length of the given string.
Auxiliary Space: O(n)


My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!