检查N的任何排列是否等于K的幂

给定一个正整数N和K，其中

$2 \leq N \leq 10^{18}$

和

$2 \leq K \leq N$

。任务是检查N的任何数字排列是否等于K的任何幂。如果可能，返回“ True ”，否则返回“ False ”。
例子：

Input: N = 96889010407, K = 7
Output: True
Explanation: 96889010407 = 713

Input : N = 123456789, K = 4
Output : False

方法：天真的方法是生成N的所有数字排列，然后逐一检查是否可以将K的任意幂整除。
高效方法：我们知道K的所有幂的总数不会超过log _K (10 ¹⁸ ) ，例如：如果K = 2，则最多将有64个K的幂。我们生成K的所有幂并将其存储在数组中。
现在，我们迭代数组中的所有数字，并检查它是否包含N的所有数字。
下面是上述方法的实现：

C++

// CPP implementation of above approach
#include 
using namespace std;
 
// function to check if N and K are anagrams
bool isValid(long long int N, long long int K)
{
    multiset m1, m2;
 
    while (N > 0) {
        m1.insert(N % 10);
        N /= 10;
    }
 
    while (K > 0) {
        m2.insert(K % 10);
        K /= 10;
    }
 
    if (m1 == m2)
        return true;
    return false;
}
 
// Function to check if any permutation of N exist
// such that it is some power of K
string anyPermutation(long long int N, long long int K)
{
    long long int powK[100], Limit = pow(10, 18);
 
    // generate all power of K under 10^18
    powK[0] = K;
 
    int i = 1;
    while (powK[i - 1] * K < Limit) {
        powK[i] = powK[i - 1] * K;
        i++;
    }
 
    // check if any power of K is valid
    for (int j = 0; j < i; j++)
        if (isValid(N, powK[j])) {
            return "True";
        }
 
    return "False";
}
 
// Driver program
int main()
{
    long long int N = 96889010407, K = 7;
 
    // function call to print required answer
    cout << anyPermutation(N, K);
 
    return 0;
}
 
// This code is written by Sanjit_Prasad

Java

// Java implementation of above approach.
import java.util.*;
 
class GfG
{
 
    // function to check if N and K are anagrams
    static boolean isValid(int N, int K)
    {
        HashSet m1 = new HashSet();
        HashSet m2 = new HashSet();
        while (N > 0)
        {
            m1.add(N % 10);
            N /= 10;
        }
 
        while (K > 0)
        {
            m2.add(K % 10);
            K /= 10;
        }
 
        if (m1.equals(m2))
        {
            return true;
        }
        return false;
    }
 
    // Function to check if any
    // permutation of N exist
    // such that it is some power of K
    static String anyPermutation(int N, int K)
    {
        int powK[] = new int[100 + 1], Limit = (int) Math.pow(10, 18);
 
        // generate all power of K under 10^18
        powK[0] = K;
 
        int i = 1;
        while (powK[i - 1] * K < Limit && i<100)
        {
            powK[i] = powK[i - 1] * K;
            i++;
        }
 
        // check if any power of K is valid
        for (int j = 0; j < i; j++)
        {
            if (isValid(N, powK[j]))
            {
                return "True";
            }
        }
 
        return "False";
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int N = (int) 96889010407L, K = 7;
 
        // function call to print required answer
        System.out.println(anyPermutation(N, K));
    }
}
 
// This code contributed by Rajput-Ji

Python 3

# Python 3 implementation of above approach
 
# function to check if N
# and K are anagrams
def isValid(N, K):
 
    m1 = []
    m2 = []
 
    while (N > 0) :
        m1.append(N % 10)
        N //= 10
 
    while (K > 0) :
        m2.append(K % 10)
        K //= 10
 
    if (m1 == m2):
        return True
    return False
 
# Function to check if any permutation
# of N exist such that it is some power of K
def anyPermutation(N, K):
 
    powK = [0] * 100
    Limit = pow(10, 18)
 
    # generate all power of
    # K under 10^18
    powK[0] = K
 
    i = 1
    while (powK[i - 1] * K < Limit) :
        powK[i] = powK[i - 1] * K
        i += 1
 
    # check if any power of K is valid
    for j in range(i):
        if (isValid(N, powK[j])) :
            return "True"
 
    return "False"
 
# Driver Code
if __name__ == "__main__":
 
    N = 96889010407
    K = 7
 
    # function call to print
    # required answer
    print(anyPermutation(N, K))
 
# This code is contributed
# by ChitraNayal

C#

// C# implementation of above approach.
using System;
using System.Collections.Generic;
class GfG{
 
// Function to check if N and K are anagrams
static bool isValid(long N, int K)
{
  HashSet m1 = new HashSet();
  HashSet m2 = new HashSet();
  while (N > 0)
  {
    m1.Add(N % 10);
    N /= 10;
  }
 
  while (K > 0)
  {
    m2.Add(K % 10);
    K /= 10;
  }
 
  if (m1.Equals(m2))
  {
    return true;
  }
  return false;
}
 
// Function to check if any
// permutation of N exist
// such that it is some power of K
static String anyPermutation(long N,
                             int K)
{
  int []powK = new int[100 + 1];
  int Limit = (int) Math.Pow(10, 18);
 
  // Generate all power
  // of K under 10^18
  powK[0] = K;
 
  int i = 1;
  while (powK[i - 1] * K < Limit && i < 100)
  {
    powK[i] = powK[i - 1] * K;
    i++;
  }
 
  // Check if any power of K is valid
  for (int j = 0; j < i; j++)
  {
    if (!isValid(N, powK[j]))
    {
      return "True";
    }
  }
 
  return "False";
}
 
// Driver code
public static void Main(String[] args)
{
  long N = 96889010407;
  int K = 7;
 
  // Function call to print required answer
  Console.WriteLine(anyPermutation(N, K));
}
}
 
// This code is contributed by gauravrajput1

输出：

True

时间复杂度： O(log _K (10 ¹⁸ ) ² )