Given an integer **K** such that there is a set of all possible perfect squares, each of length **K**. From this set of perfect squares, form a set of the longest possible length having those numbers which are anagram to each other. The task is to print the largest element present in the generated set of anagrams.**Note:** If there is more than one set of maximum length, then print the largest number among them.

The

anagramof a string is another string that contains the same characters, only the order of characters are different.

**Examples:**

Input:K = 2Output:81Explanation:

All possible squares of length K = 2 are {16, 25, 36, 49, 64, 81}.

The possible anagram sets are [16], [25], [36], [49], [64], [81].

Therefore, each set is of the same size i.e., 1.

In this case, print the set containing the largest element, which is 81.

Input:K = 5Output:96100

**Naive Approach:** The simplest approach is to store all possible** K** length perfect squares and form a valid anagram sets using recursion. Then, find the maximum element present in the set of longest length.

**Time Complexity:** O(N^{2})**Auxiliary Space:** O(N)

**Efficient Approach:** The idea is based on the observation that on sorting the digits of the perfect squares, the sequence of anagram numbers becomes equal. Below are the steps:

- Initialise a Map to store all the anagram numbers corresponding to the numbers whose digit are arranged in sorted order.
- Generate all the perfect squares of length
**K**. - For each perfect square generated, insert the number in the
**Map**corresponding to the number whose digit is arranged in ascending order. - Traverse the
**Map**and print the largest number from the set of maximum length.

Below is the implementation of the above approach:

## CPP

`// C++ program for the above approach` ` ` `#include <bits/stdc++.h>` `using` `namespace` `std;` ` ` `// Function to find the largest set of` `// perfect squares which are anagram` `// to each other` `void` `printResult(` ` ` `map<string, set<` `long` `long` `int` `> > m)` `{` ` ` `auto` `max_itr = m.begin();` ` ` ` ` `long` `long` `maxi = -1;` ` ` ` ` `for` `(` `auto` `itr = m.begin();` ` ` `itr != m.end(); ++itr) {` ` ` ` ` `long` `long` `int` `siz1` ` ` `= (itr->second).size();` ` ` ` ` `// Check if size of maximum set` ` ` `// is less than the current set` ` ` `if` `(maxi < siz1) {` ` ` ` ` `// Update maximum set` ` ` `maxi = siz1;` ` ` `max_itr = itr;` ` ` `}` ` ` ` ` `// If lengths are equal` ` ` `else` `if` `(maxi == siz1) {` ` ` ` ` `// Update maximum set to store` ` ` `// the set with maximum element` ` ` `if` `((*(max_itr->second).rbegin())` ` ` `< *(itr->second.rbegin())) {` ` ` `maxi = siz1;` ` ` `max_itr = itr;` ` ` `}` ` ` `}` ` ` `}` ` ` ` ` `// Stores the max element from the set` ` ` `long` `long` `int` `result` ` ` `= *(max_itr->second).rbegin();` ` ` ` ` `// Print final Result` ` ` `cout << result << endl;` `}` ` ` `// Function to find the` `// perfect squares wich are anagrams` `void` `anagramicSquares(` `long` `long` `int` `k)` `{` ` ` `// Stores the sequence` ` ` `map<string, set<` `long` `long` `int` `> > m;` ` ` ` ` `// Initialize start and end` ` ` `// of perfect squares` ` ` `long` `long` `int` `end;` ` ` `if` `(k % 2 == 0)` ` ` `end = k / 2;` ` ` `else` ` ` `end = ((k + 1) / 2);` ` ` ` ` `long` `long` `int` `start = ` `pow` `(10, end - 1);` ` ` `end = ` `pow` `(10, end);` ` ` ` ` `// Iterate form start to end` ` ` `for` `(` `long` `long` `int` `i = start;` ` ` `i <= end; i++) {` ` ` ` ` `long` `long` `int` `x = i * i;` ` ` ` ` `// Converting int to string` ` ` `ostringstream str1;` ` ` `str1 << x;` ` ` ` ` `string str = str1.str();` ` ` `if` `(str.length() == k) {` ` ` ` ` `// Sort string for storing` ` ` `// number at exact map position` ` ` `sort(str.begin(), str.end());` ` ` ` ` `// Insert number at map` ` ` `m[str].insert(x);` ` ` `}` ` ` `}` ` ` ` ` `// Print result` ` ` `printResult(m);` `}` ` ` `// Driver Code` `int` `main()` `{` ` ` `// Given K` ` ` `long` `long` `int` `K = 2;` ` ` ` ` `// Function Call` ` ` `anagramicSquares(K);` ` ` ` ` `return` `0;` `}` |

**Output:**

81

**Time Complexity:** O(N)**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.