Skip to content
Related Articles

Related Articles

Improve Article

Count of pairs of strings whose concatenation forms a palindromic string

  • Difficulty Level : Easy
  • Last Updated : 20 Aug, 2020

Given an array A[ ] consisting of N strings, the task is to count the number of pairs of possible strings that on merging forms a Palindromic String or can be rearranged to form a Palindromic String. 

Example :

Input: N = 6, A[ ] = {aab, abcac, dffe, ed, aa, aade}
Output: 6
Explanation: 
All possible pairs of strings which generates a palindromic string: 
{aab, abcac} = aabccbaa
{aab, aa} = aabaa
{abcac, aa} = aacbcaa
{dffe, ed} = fdeedf
{dffe, aade} = edfaafde
{ed, aade} = edaade or aeddea
Hence, total possible pairs = 6

 Input: N = 3, A[ ] = {aa, bb, cd}
Output: 1
Explanation: 
The only possible pair of strings which generates palindromic string: 
{aa, bb} = abba
Hence, total possible pairs = 1

Naive Approach:
The simplest approach to solve this problem is to generate all possible pairs from the given array and merge these pairs to generate new strings. For each of those merged strings, generate all possible permutations of the string and for each permutation, check whether it is a palindromic string or not and increment the count accordingly. 
Time Complexity: O(N2 * L! * L), where L is the maximum length of a string.
Auxiliary Space: O(M)

Efficient Approach:
A palindromic string can always be formed when at most one character has an odd occurrence and remaining every character has even occurrence. Since rearrangement of the characters in the merged string is allowed, so we only need to count the frequency of characters in the merged string and check if it satisfies to be a palindromic string or not.



Illustration:
1. Every character has even occurrence
Strings “aab” and “abcac” can be merged and rearranged to form a palindromic string “aababcac” with each character having even frequency

2. One character has odd occurrence
Strings “aab” and “aa” can be merged to form a palindromic string “aabaa” with a character(‘b’) having odd frequency and the rest having even frequency.

Hence, it can be observed that two pairs of strings of the following types can be merged to form a palindromic string:

  • The frequency of each character in both strings are same.
  • At most one character in both the strings has a different frequency.

Follow the steps below to solve the problem:

  • Traverse the given array and for every string,  store the frequency of each character.
  • Assign parity (0 or 1) to each frequency. Assign 0 for even frequency and 1 for odd frequency.
  • Initialize a map to store the frequencies of each frequency array generated.
  • Since, rearrangement is allowed, reverse the parity of each character and include the frequency array in map.
  • Finally, return the total count of similar frequency arrays, which will give the required count of pairs.

Below is the implementation of the above approach:

C++




// C++ Program to find 
// palindromic string 
#include <bits/stdc++.h> 
using namespace std; 
  
int getCount(int N, vector<string>& s) 
{ 
    // Stores frequency array 
    // and its count 
    map<vector<int>, int> mp; 
  
    // Total number of pairs 
    int ans = 0; 
  
    for (int i = 0; i < N; i++) { 
  
        // Initializing array of size 26 
        // to store count of character 
        vector<int> a(26, 0); 
  
        // Counting occurrence of each 
        // character of current string 
        for (int j = 0; j < s[i].size(); j++) { 
  
            a[s[i][j] - 'a']++; 
        } 
  
        // Convert each count to parity(0 or 1) 
        // on the basis of its frequency 
        for (int j = 0; j < 26; j++) { 
  
            a[j] = a[j] % 2; 
        } 
  
        // Adding to anser 
        ans += mp[a]; 
  
        // Frequency of single character 
        // can be possibly changed, 
        // so change its parity 
        for (int j = 0; j < 26; j++) { 
  
            vector<int> changedCount = a; 
  
            if (a[j] == 0) 
                changedCount[j] = 1; 
            else
                changedCount[j] = 0; 
  
            ans += mp[changedCount]; 
        } 
  
        mp[a]++; 
    } 
  
    return ans; 
} 
  
int main() 
{ 
    int N = 6; 
    vector<string> A 
        = { "aab", "abcac", "dffe", 
            "ed", "aa", "aade" }; 
  
    cout << getCount(N, A); 
  
    return 0; 
}
Java



// Java program to find 
// palindromic string 
import java.util.*;
  
class GFG{
  
static int getCount(int N, List<String> s) 
{ 
      
    // Stores frequency array 
    // and its count 
    Map<List<Integer>, Integer> mp = new HashMap<>(); 
      
    // Total number of pairs 
    int ans = 0; 
      
    for(int i = 0; i < N; i++)
    { 
          
        // Initializing array of size 26 
        // to store count of character 
        List<Integer> a = new ArrayList<>(26);
        for(int k = 0; k < 26; k++)
            a.add(0);
          
        // Counting occurrence of each 
        // character of current string 
        for(int j = 0; j < s.get(i).length(); j++)
        { 
            a.set((s.get(i).charAt(j) - 'a'),
             a.get(s.get(i).charAt(j) - 'a') + 1); 
        } 
  
        // Convert each count to parity(0 or 1) 
        // on the basis of its frequency 
        for(int j = 0; j < 26; j++)
        { 
            a.set(j, a.get(j) % 2);
        } 
          
        // Adding to anser 
        ans += mp.getOrDefault(a, 0); 
          
        // Frequency of single character 
        // can be possibly changed, 
        // so change its parity 
        for(int j = 0; j < 26; j++) 
        { 
            List<Integer> changedCount = new ArrayList<>();
            changedCount.addAll(a);
              
            if (a.get(j) == 0) 
                changedCount.set(j, 1); 
            else
                changedCount.set(j, 0); 
              
            ans += mp.getOrDefault(changedCount, 0); 
        } 
        mp.put(a, mp.getOrDefault(a, 0) + 1);
    } 
    return ans; 
}
  
// Driver code
public static void main (String[] args)
{
    int N = 6; 
    List<String> A = Arrays.asList("aab", "abcac",
                                   "dffe", "ed", 
                                   "aa", "aade"); 
      
    System.out.print(getCount(N, A)); 
}
}
  
// This code is contributed by offbeat
Python3



# Python3 program to find 
# palindromic string 
from collections import defaultdict 
  
def getCount(N, s): 
  
    # Stores frequency array 
    # and its count 
    mp = defaultdict(lambda: 0) 
  
    # Total number of pairs 
    ans = 0
  
    for i in range(N): 
  
        # Initializing array of size 26 
        # to store count of character 
        a = [0] * 26
  
        # Counting occurrence of each 
        # character of current string 
        for j in range(len(s[i])): 
            a[ord(s[i][j]) - ord('a')] += 1
  
        # Convert each count to parity(0 or 1) 
        # on the basis of its frequency 
        for j in range(26): 
            a[j] = a[j] % 2
  
        # Adding to anser 
        ans += mp[tuple(a)] 
  
        # Frequency of single character 
        # can be possibly changed, 
        # so change its parity 
        for j in range(26): 
            changedCount = a[:] 
            if (a[j] == 0): 
                changedCount[j] = 1
            else: 
                changedCount[j] = 0
            ans += mp[tuple(changedCount)] 
  
        mp[tuple(a)] += 1
  
    return ans 
  
# Driver code 
if __name__ == '__main__': 
      
    N = 6
    A = [ "aab", "abcac", "dffe", 
        "ed", "aa", "aade" ] 
  
    print(getCount(N, A)) 
  
# This code is contributed by Shivam Singh 
Output: 
6

Time Complexity: O(N*(L+log(N))), where L is the maximum length of a string
Auxiliary Space: 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
Previous
Introduction to Chempy in Python
Next

Count of triplets in an Array such that A[i] * A[j] = A[k] and i < j < k
Recommended Articles
Page :
Check if 2 * K + 1 non-empty strings exists whose concatenation forms the given string
26, Apr 21
Count of three non-overlapping sub-strings which on concatenation forms a palindrome
29, May 19
Subarray of length K whose concatenation forms a palindrome
06, Oct 20
Check if concatenation of splitted substrings of two given strings forms a palindrome or not
02, Dec 20
Longest palindromic String formed using concatenation of given strings in any order
18, Feb 20
Longest palindromic string formed by concatenation of prefix and suffix of a string
06, May 20
Minimum characters to be replaced to make a string concatenation of a K-length palindromic string
19, Nov 20
Count pair of strings whose concatenation of substrings form a palindrome
20, Jun 20
Count pair of strings whose concatenation has every vowel
15, Jul 20
Count pairs of non-overlapping palindromic sub-strings of the given string
12, Apr 19
Check if concatenation of first and last digits forms a prime number or not for each array element
02, Mar 21
Rearrange characters of a string to make it a concatenation of palindromic substrings
17, Mar 21
Minimum cuts required to convert a palindromic string to a different palindromic string
12, Mar 19
Pairs whose concatenation contain all digits
20, May 18
Maximize sum of array by repeatedly removing an element from pairs whose concatenation is a multiple of 3
03, May 21
Count new pairs of strings that can be obtained by swapping first characters of pairs of strings from given array
14, Apr 21
Make palindromic string non-palindromic by rearranging its letters
29, Jan 19
Count maximum concatenation of pairs from given array that are divisible by 3
04, Jan 21
Count of unique palindromic strings of length X from given string
14, Jul 20
Check if a string can be made palindromic by swapping pairs of characters from indices having unequal characters in a Binary String
31, Mar 21
Partition a string into palindromic strings of at least length 2 with every character present in a single string
23, Mar 21
Maximize count of pairs whose Bitwise AND exceeds Bitwise XOR by replacing such pairs with their Bitwise AND
22, Feb 21
Maximize count of pairs whose bitwise XOR is even by replacing such pairs with their Bitwise XOR
22, Feb 21
Longest Palindromic Substring using Palindromic Tree | Set 3
18, Apr 18
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
maddy1706
@maddy1706
Vote for difficulty
Current difficulty :
Easy





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox