# Form minimum number of Palindromic Strings from a given string

• Difficulty Level : Medium
• Last Updated : 09 Nov, 2021

Given a string S, the task is to divide the characters of S to form minimum number of palindromic strings.

Note: There can be multiple correct answers.

Examples:

Input: S = “geeksforgeeks”
Output: {eegksrskgee, o, f}

Explanation:
There should be at least 3 strings “eegksrskgee”, “o”, “f”. All 3 formed strings are palindrome.

Input: S = “abbaa”
Output: {“ababa”}

Explanation:
The given string S = “ababa” is already a palindrome string so, only 1 string will be formed.

Input: S = “abc”
Output: {“a”, “b”, “c”}

Explanation:
There should be at least 3 strings “a”, “b”, “c”. All 3 formed strings are palindrome.

Approach:

The main observation is that a palindrome string remains the same if reversed. The length of the strings formed does not matter so try to make a string as large as possible. If some character can’t be a part of palindromic string, then push this character into a new string.

• The general approach would be to store the frequency of each character and if for some character the frequency is odd then we have to make a new string and increment our answer by 1.
• Note that if there are no characters with odd frequency, at least one string is still needed, so the final answer will be max(1, odd frequency characters).
• To print the string store odd characters frequency characters in a vector and even characters in another vector.
• Form one palindromic string with strings having odd characters and append a string with an even number of characters and all other strings will be of only one character.

Below is the implementation of the above approach:

## C++

 `// C++ Program to implement``// the above approach` `#include ``using` `namespace` `std;` `// Function to return``// minimum palindromic strings formed``int` `minimumPalindromicStrings(string S)``{``    ``// Store the length of string``    ``int` `N = S.length();` `    ``// Iterate over the string``    ``// and store the frequency of``    ``// all characters A vector``    ``// to store the frequency``    ``vector<``int``> freq(26);``    ``for` `(``int` `i = 0; i < N; i++) {``        ``freq[S[i] - ``'a'``]++;``    ``}` `    ``// Store the odd frequency characters``    ``vector<``int``> oddFreqCharacters;` `    ``// Store the even frequency of characters``    ``// in the same vector by dividing``    ``// current frequency by 2 as one element``    ``// will be used on left as well as right side` `    ``// Iterate through all possible characters``    ``// and check the parity of frequency``    ``for` `(``int` `i = 0; i < 26; i++) {` `        ``if` `(freq[i] & 1) {` `            ``oddFreqCharacters.push_back(i);``            ``freq[i]--;``        ``}` `        ``freq[i] /= 2;``    ``}` `    ``// store answer in a vector``    ``vector ans;` `    ``// if there are no odd Frequency characters``    ``// then print the string with even characters``    ``if` `(oddFreqCharacters.empty()) {` `        ``// store the left part``        ``// of the palindromic string``        ``string left = ``""``;` `        ``for` `(``int` `i = 0; i < 26; i++) {``            ``for` `(``int` `j = 0; j < freq[i]; j++) {` `                ``left += ``char``(i + ``'a'``);``            ``}``        ``}` `        ``string right = left;` `        ``// reverse the right part of the string``        ``reverse(right.begin(), right.end());` `        ``// store the string in ans vector``        ``ans.push_back(left + right);``    ``}` `    ``else` `{` `        ``// take any character``        ``// from off frequency element``        ``string middle = ``""``;``        ``int` `c = oddFreqCharacters.back();``        ``oddFreqCharacters.pop_back();``        ``middle += ``char``(c + ``'a'``);` `        ``// repeat the above step to form``        ``// left and right strings``        ``string left = ``""``;` `        ``for` `(``int` `i = 0; i < 26; i++) {``            ``for` `(``int` `j = 0; j < freq[i]; j++) {` `                ``left += ``char``(i + ``'a'``);``            ``}``        ``}` `        ``string right = left;` `        ``// reverse the right part of the string``        ``reverse(right.begin(), right.end());` `        ``// store the string in ans vector``        ``ans.push_back(left + middle + right);` `        ``// store all other odd frequency strings``        ``while` `(!oddFreqCharacters.empty()) {` `            ``int` `c = oddFreqCharacters.back();``            ``oddFreqCharacters.pop_back();``            ``string middle = ``""``;``            ``middle += ``char``(c + ``'a'``);``            ``ans.push_back(middle);``        ``}``    ``}` `    ``// Print the answer``    ``cout << ``"["``;``    ``for` `(``int` `i = 0; i < ans.size(); i++) {``        ``cout << ans[i];``        ``if` `(i != ans.size() - 1) {``            ``cout << ``", "``;``        ``}``    ``}``    ``cout << ``"]"``;``    ``return` `0;``}` `// Driver Code``int` `main()``{``    ``string S = ``"geeksforgeeks"``;``    ``minimumPalindromicStrings(S);``}`

## Java

 `// Java Program to implement``// the above approach``import` `java.util.*;` `class` `GFG{` `// Function to return``// minimum palindromic Strings formed``static` `int` `minimumPalindromicStrings(String S)``{``  ` `    ``// Store the length of String``    ``int` `N = S.length();` `    ``// Iterate over the String``    ``// and store the frequency of``    ``// all characters A vector``    ``// to store the frequency``   ``int``[] freq = ``new` `int``[``26``];``    ``for` `(``int` `i = ``0``; i < N; i++) {``        ``freq[S.charAt(i) - ``'a'``]++;``    ``}` `    ``// Store the odd frequency characters``    ``Vector oddFreqCharacters = ``new` `Vector();` `    ``// Store the even frequency of characters``    ``// in the same vector by dividing``    ``// current frequency by 2 as one element``    ``// will be used on left as well as right side` `    ``// Iterate through all possible characters``    ``// and check the parity of frequency``    ``for` `(``int` `i = ``0``; i < ``26``; i++) {` `        ``if` `(freq[i] % ``2` `== ``1``) {` `            ``oddFreqCharacters.add(i);``            ``freq[i]--;``        ``}` `        ``freq[i] /= ``2``;``    ``}` `    ``// store answer in a vector``    ``Vector ans = ``new` `Vector();` `    ``// if there are no odd Frequency characters``    ``// then print the String with even characters``    ``if` `(oddFreqCharacters.isEmpty()) {` `        ``// store the left part``        ``// of the palindromic String``        ``String left = ``""``;` `        ``for` `(``int` `i = ``0``; i < ``26``; i++) {``            ``for` `(``int` `j = ``0``; j < freq[i]; j++) {` `                ``left += (``char``)(i + ``'a'``);``            ``}``        ``}` `        ``String right = left;` `        ``// reverse the right part of the String``        ``right = reverse(right);` `        ``// store the String in ans vector``        ``ans.add(left + right);``    ``}` `    ``else` `{` `        ``// take any character``        ``// from off frequency element``        ``String middle = ``""``;``        ``int` `c = oddFreqCharacters.lastElement();``        ``oddFreqCharacters.remove(oddFreqCharacters.size()-``1``);``        ``middle += (``char``)(c + ``'a'``);` `        ``// repeat the above step to form``        ``// left and right Strings``        ``String left = ``""``;` `        ``for` `(``int` `i = ``0``; i < ``26``; i++) {``            ``for` `(``int` `j = ``0``; j < freq[i]; j++) {` `                ``left += (``char``)(i + ``'a'``);``            ``}``        ``}` `        ``String right = left;` `        ``// reverse the right part of the String``        ``right = reverse(right);` `        ``// store the String in ans vector``        ``ans.add(left + middle + right);` `        ``// store all other odd frequency Strings``        ``while` `(!oddFreqCharacters.isEmpty()) {` `            ``c = oddFreqCharacters.lastElement();``            ``oddFreqCharacters.remove(oddFreqCharacters.size()-``1``);``            ``middle = ``""``;``            ``middle += (``char``)(c + ``'a'``);``            ``ans.add(middle);``        ``}``    ``}` `    ``// Print the answer``    ``System.out.print(``"["``);``    ``for` `(``int` `i = ``0``; i < ans.size(); i++) {``        ``System.out.print(ans.get(i));``        ``if` `(i != ans.size() - ``1``) {``            ``System.out.print(``", "``);``        ``}``    ``}``    ``System.out.print(``"]"``);``    ``return` `0``;``}``static` `String reverse(String input) {``    ``char``[] a = input.toCharArray();``    ``int` `l, r = a.length - ``1``;``    ``for` `(l = ``0``; l < r; l++, r--) {``        ``char` `temp = a[l];``        ``a[l] = a[r];``        ``a[r] = temp;``    ``}``    ``return` `String.valueOf(a);``}``  ` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``String S = ``"geeksforgeeks"``;``    ``minimumPalindromicStrings(S);``}``}` `// This code is contributed by 29AjayKumar`

## C#

 `// C# Program to implement``// the above approach``using` `System;``using` `System.Collections.Generic;` `public` `class` `GFG{` `// Function to return``// minimum palindromic Strings formed``static` `int` `minimumPalindromicStrings(String S)``{``  ` `    ``// Store the length of String``    ``int` `N = S.Length;` `    ``// Iterate over the String``    ``// and store the frequency of``    ``// all characters A vector``    ``// to store the frequency``   ``int``[] freq = ``new` `int``;``    ``for` `(``int` `i = 0; i < N; i++) {``        ``freq[S[i] - ``'a'``]++;``    ``}` `    ``// Store the odd frequency characters``    ``List<``int``> oddFreqchars = ``new` `List<``int``>();` `    ``// Store the even frequency of characters``    ``// in the same vector by dividing``    ``// current frequency by 2 as one element``    ``// will be used on left as well as right side` `    ``// Iterate through all possible characters``    ``// and check the parity of frequency``    ``for` `(``int` `i = 0; i < 26; i++) {` `        ``if` `(freq[i] % 2 == 1) {` `            ``oddFreqchars.Add(i);``            ``freq[i]--;``        ``}` `        ``freq[i] /= 2;``    ``}` `    ``// store answer in a vector``    ``List ans = ``new` `List();` `    ``// if there are no odd Frequency characters``    ``// then print the String with even characters``    ``if` `(oddFreqchars.Count==0) {` `        ``// store the left part``        ``// of the palindromic String``        ``String left = ``""``;` `        ``for` `(``int` `i = 0; i < 26; i++) {``            ``for` `(``int` `j = 0; j < freq[i]; j++) {` `                ``left += (``char``)(i + ``'a'``);``            ``}``        ``}` `        ``String right = left;` `        ``// reverse the right part of the String``        ``right = reverse(right);` `        ``// store the String in ans vector``        ``ans.Add(left + right);``    ``}` `    ``else` `{` `        ``// take any character``        ``// from off frequency element``        ``String middle = ``""``;``        ``int` `c = oddFreqchars[oddFreqchars.Count-1];``        ``oddFreqchars.RemoveAt(oddFreqchars.Count-1);``        ``middle += (``char``)(c + ``'a'``);`` ` `        ``// repeat the above step to form``        ``// left and right Strings``        ``String left = ``""``;` `        ``for` `(``int` `i = 0; i < 26; i++) {``            ``for` `(``int` `j = 0; j < freq[i]; j++) {` `                ``left += (``char``)(i + ``'a'``);``            ``}``        ``}` `        ``String right = left;` `        ``// reverse the right part of the String``        ``right = reverse(right);` `        ``// store the String in ans vector``        ``ans.Add(left + middle + right);` `        ``// store all other odd frequency Strings``        ``while` `(oddFreqchars.Count!=0) {` `            ``c = oddFreqchars[oddFreqchars.Count-1];``            ``oddFreqchars.RemoveAt(oddFreqchars.Count-1);``            ``middle = ``""``;``            ``middle += (``char``)(c + ``'a'``);``            ``ans.Add(middle);``        ``}``    ``}` `    ``// Print the answer``    ``Console.Write(``"["``);``    ``for` `(``int` `i = 0; i < ans.Count; i++) {``        ``Console.Write(ans[i]);``        ``if` `(i != ans.Count - 1) {``            ``Console.Write(``", "``);``        ``}``    ``}``    ``Console.Write(``"]"``);``    ``return` `0;``}``static` `String reverse(String input) {``    ``char``[] a = input.ToCharArray();``    ``int` `l, r = a.Length - 1;``    ``for` `(l = 0; l < r; l++, r--) {``        ``char` `temp = a[l];``        ``a[l] = a[r];``        ``a[r] = temp;``    ``}``    ``return` `String.Join(``""``,a);``}``  ` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``String S = ``"geeksforgeeks"``;``    ``minimumPalindromicStrings(S);``}``}` ` `  `// This code is contributed by 29AjayKumar`
Output:
`[eegksrskgee, o, f]`

Time Complexity: O(N*26)

Space Complexity: O(N)

My Personal Notes arrow_drop_up