从长度为 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. 初始化一个 Map 来存储所有数字按排序顺序排列的数字对应的字谜数字。
2. 生成长度为K 的所有完美平方。
3. 对于生成的每个完全正方形，将数字按升序排列的数字对应的数字插入到 Map 中。
4. 遍历Map并打印最大长度集合中的最大数字。

下面是上述方法的实现：

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)