Find the size of largest subset of anagram words

Difficulty Level : Hard
Last Updated : 24 Dec, 2020

Given an array of n string containing lowercase letters. Find the size of largest subset of string which are anagram of each others. An anagram of a string is another string that contains same characters, only the order of characters can be different. For example, “abcd” and “dabc” are anagram of each other.

Input: 
ant magenta magnate tan gnamate
Output: 3
Explanation
Anagram strings(1) - ant, tan
Anagram strings(2) - magenta, magnate,
                     gnamate
Thus, only second subset have largest
size i.e., 3

Input: 
cars bikes arcs steer 
Output: 2

Naive approach is to generate all possible subset and iterate from largest size of subset containing all string having same size and anagram of each others. Time complexity of this approach is O( $2^n m$ ) where n and m are the size of array and length of string respectively.
Efficient approach is to use hashing and sorting. Sort all characters of string and store the hash value(sorted string) in map(unordered_map in C++ and HashMap in java). At last check which one is the frequency sorted word with the highest number of occurrence.

C++

// C++ Program to find the size of
// largest subset of anagram
#include <bits/stdc++.h>
using namespace std;
 
// Utility function to find size of
// largest subset of anagram
int largestAnagramSet(string arr[], int n)
{
 
    int maxSize = 0;
    unordered_map<string, int> count;
 
    for (int i = 0; i < n; ++i) {
 
        // sort the string
        sort(arr[i].begin(), arr[i].end());
 
        // Increment the count of string
        count[arr[i]] += 1;
 
        // Compute the maximum size of string
        maxSize = max(maxSize, count[arr[i]]);
    }
 
    return maxSize;
}
 
// Driver code
int main()
{
    string arr[] = { "ant", "magenta",
               "magnate", "tan", "gnamate" };
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << largestAnagramSet(arr, n) << "\n";
 
    string arr1[] = { "cars", "bikes", "arcs",
                                     "steer" };
    n = sizeof(arr1) / sizeof(arr[0]);
    cout << largestAnagramSet(arr1, n);
    return 0;
}

Java

// Java Program to find the size of
// largest subset of anagram
import java.util.*;
 
class GFG
{
 
// Utility function to find size of
// largest subset of anagram
static int largestAnagramSet(String arr[], int n)
{
    int maxSize = 0;
    HashMap<String, Integer> count = new HashMap<>();
 
    for (int i = 0; i < n; ++i)
    {
 
        // sort the String
        char temp[] = arr[i].toCharArray();
        Arrays.sort(temp);
        arr[i] = new String(temp);
         
        // Increment the count of String
        if(count.containsKey(arr[i]))
        {
            count.put(arr[i], count.get(arr[i]) + 1);
        }
        else
        {
            count.put(arr[i], 1);
        }
 
        // Compute the maximum size of String
        maxSize = Math.max(maxSize, count.get(arr[i]));
    }
    return maxSize;
}
 
// Driver code
public static void main(String[] args)
{
    String arr[] = { "ant", "magenta",
                     "magnate", "tan", "gnamate" };
    int n = arr.length;
    System.out.println(largestAnagramSet(arr, n));
 
    String arr1[] = { "cars", "bikes",
                      "arcs", "steer" };
    n = arr1.length;
    System.out.println(largestAnagramSet(arr1, n));
}
}
 
// This code is contributed by 29AjayKumar

Python3

# Python3 Program to find the size of
# largest subset of anagram
 
# Utility function to find size of
# largest subset of anagram
def largestAnagramSet(arr, n) :
 
    maxSize = 0
    count = {}
 
    for i in range(n) :
 
        # sort the string
        arr[i] = ''.join(sorted(arr[i]))
 
        # Increment the count of string
        if arr[i] in count :
            count[arr[i]] += 1
        else :
            count[arr[i]] = 1
 
        # Compute the maximum size of string
        maxSize = max(maxSize, count[arr[i]])
 
    return maxSize
 
# Driver code
arr = [ "ant", "magenta", "magnate", "tan", "gnamate" ]
n = len(arr)
print(largestAnagramSet(arr, n))
 
arr1 = [ "cars", "bikes", "arcs", "steer" ]
n = len(arr1)
print(largestAnagramSet(arr1, n))
 
# This code is contributed by divyeshrabadiya072019

C#

// C# Program to find the size of
// largest subset of anagram
using System;
using System.Collections.Generic;
 
class GFG
{
 
// Utility function to find size of
// largest subset of anagram
static int largestAnagramSet(String []arr, int n)
{
    int maxSize = 0;
 
    Dictionary<String,
               int> count = new Dictionary<String,
                                           int>();
    for (int i = 0; i < n; ++i)
    {
 
        // sort the String
        char []temp = arr[i].ToCharArray();
        Array.Sort(temp);
        arr[i] = new String(temp);
         
        // Increment the count of String
        if(count.ContainsKey(arr[i]))
        {
            count[arr[i]] = count[arr[i]] + 1;
        }
        else
        {
            count.Add(arr[i], 1);
        }
 
        // Compute the maximum size of String
        maxSize = Math.Max(maxSize, count[arr[i]]);
    }
    return maxSize;
}
 
// Driver code
public static void Main(String[] args)
{
    String []arr = {"ant", "magenta",
                    "magnate", "tan", "gnamate"};
    int n = arr.Length;
    Console.WriteLine(largestAnagramSet(arr, n));
 
    String []arr1 = {"cars", "bikes",
                     "arcs", "steer"};
    n = arr1.Length;
    Console.WriteLine(largestAnagramSet(arr1, n));
}
}
 
// This code is contributed by Rajput-Ji

Output:

3
2

Time complexity: O( $nm\log(m)$ ) where m is maximum size among all of the strings
Auxiliary space: O(n + m)
Best approach is to store the frequency array of each word. In this, we just need to iterate over the characters of the words and increment the frequency of current letter. At last, increment the count of only identical frequency array[] and take the maximum among them. This approach is best only when length of strings are maximum in comparison to the array size.

cpp

// C++ Program to find the size of
// largest subset of anagram
#include <bits/stdc++.h>
using namespace std;
 
// Utility function to find size of
// largest subset of anagram
int largestAnagramSet(string arr[], int n)
{
    int maxSize = 0;
 
    // Initialize map<> of vector array
    map<vector<int>, int> count;
 
    for (int i = 0; i < n; ++i) {
 
        // Vector array to store
        // frequency of element
        vector<int> freq(26);
 
        for (char ch : arr[i])
            freq[ch - 'a'] += 1;
 
        // Increment the count of
        // frequency array in map<>
        count[freq] += 1;
 
        // Compute the maximum size
        maxSize = max(maxSize, count[freq]);
    }
    return maxSize;
}
 
// Driver code
int main()
{
    string arr[] = { "ant", "magenta", "magnate",
                              "tan", "gnamate" };
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << largestAnagramSet(arr, n) << "\n";
 
    string arr1[] = { "cars", "bikes", "arcs",
                                     "steer" };
    n = sizeof(arr1) / sizeof(arr[0]);
    cout << largestAnagramSet(arr1, n);
    return 0;
}

Python3

# Python Program to find the size of
# largest subset of anagram
 
# Utility function to find size of
# largest subset of anagram
def largestAnagramSet(arr, n):
    maxSize = 0
 
    # Initialize dictionary of array
    count = {}
    for i in range(n):
       
        # list to store
        # frequency of element
        freq=[0 for i in range(26)]
 
        for ch in arr[i]:
            freq[ord(ch) - ord('a')] += 1
 
        # Increment the count of
        # frequency array in dictionary
        temp = "".join(str(i) for i in freq)
        if temp not in count:
            count[temp] = 1
        else:
            count[temp] += 1
 
        # Compute the maximum size
        maxSize = max(maxSize, count[temp])
    return maxSize
 
# Driver code
arr = ["ant", "magenta", "magnate","tan", "gnamate"]
n = len(arr)
print(largestAnagramSet(arr, n))
 
arr1 = ["cars", "bikes", "arcs", "steer"]
n = len(arr1)
print(largestAnagramSet(arr1, n))
 
# This code is contributed by rag2127

Output
3
2

Time complexity: O( $nm\log(n)$ ) where m is maximum size among all of the strings
Auxiliary space: O(n + m)

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 industry experts, please refer Geeks Classes Live

My Personal Notes

May	JUN	Jul
	15
2020	2021	2022

Related Articles

C++

Java

Python3

C#

cpp

Python3