Count maximum-length palindromes in a String

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 c_i be the number of occurrences of a character in the string. Consider the following cases: 

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

Let k be the number of odd c_i. 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 n₁ identical objects of type 1, n₂ 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 f_a+f_b+f_a+…….+f_y+f_z . So number of permutation is (f_a+f_b+f_a+…….+f_y+f_z)! / f_a! f_b!…f_y!f_z!.
Now If K is not 0, it’s obvious that the answer is k * (f_a+f_b+f_a+…….+f_y+f_z+)! / f_a! f_b!…f_y!f_z!

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)