来自长度为K的所有理想平方的最长字谜集合中的最大数

给定一个整数K ，使得存在一组所有可能的理想平方，每个平方的长度为K。从这组完美的正方形中，形成一组尽可能长的长度，其长度彼此相同。任务是打印在生成的字谜集中存在的最大元素。
注意：如果最大长度超过一组，则打印其中最大的一组。

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

例子：

Input: K = 2
Output: 81
Explanation:
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 = 5
Output: 96100

天真的方法：最简单的方法是存储所有可能的K长度的完美正方形，并使用递归形成有效的字谜集。然后，找到最长长度集中存在的最大元素。

时间复杂度： O(N ² )
辅助空间： O(N)

高效的方法：这个想法是基于以下观察：对完美正方形的数字进行排序后，字谜数字的顺序变得相等。步骤如下：

1. 初始化地图以存储所有与所有按字母顺序排列的数字相对应的七字谜数字。
2. 生成所有长度为K的理想平方。
3. 对于生成的每个完美平方，在地图中插入与数字以升序排列的数字相对应的数字。
4. 遍历地图并从最大长度集中打印最大的数字。

下面是上述方法的实现：

CPP

// C++ program for the above approach
  
#include 
using namespace std;
  
// Function to find the largest set of
// perfect squares which are anagram
// to each other
void printResult(
    map > 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 > 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;
}

输出：

81

时间复杂度： O(N)
辅助空间： O(N)