Related Articles

# Count maximum-length palindromes in a String

• Difficulty Level : Hard
• Last Updated : 13 Aug, 2021

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 ``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` `numberOfPossiblePallindrome(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 pallindrome,``    ``// 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 << numberOfPossiblePallindrome(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` `numberOfPossiblePallindrome(String str, ``int` `n)``{``    ``// Count number of occurrence``    ``// of a charterer in the string``    ``Map 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 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 pallindrome,``    ``// 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(numberOfPossiblePallindrome(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` `numberOfPossiblePallindrome(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 pallindrome,``    ``# 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``(numberOfPossiblePallindrome(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` `numberOfPossiblePallindrome(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 pallindrome,``    ``// 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(numberOfPossiblePallindrome(str, n));``}``}` `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output:

`4`

Time Complexity : O(n)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up