给定一个由N个正整数和K个整数组成的数组arr [] ，任务是创建一组素数，以使所有数组元素的素数分解中的所有素数幂的和可被K整除。 。
例子：
Input: arr[] = {1, 2, 3}, K = 1
Output: {2, 3}
Explanation:
2 = 21
3 = 31
The power of 2 is 1 which is divisible by K(=1).
The power of 2 is 1 which is divisible by K(=1).
Input: arr[] = {2, 2, 4, 8}, K = 10
Output: {}
Explanation:
2 = 21
2 = 21
4 = 22
8 = 23
The power of 2 is (1 + 1 + 2 + 3) = 7 which is not divisible by K(=10).
Thus, the output empty set.
天真的方法：这个想法是找到所有小于或等于数组arr []的最大元素的质数。对于每个素数计数次数，它将除以数组元素。如果count的值可被K整除，则将素数插入结果集中。在该组的最后打印元素。
时间复杂度： O(N * log(N))
辅助空间： O(N)
高效方法：为优化上述方法，其思想是预先计算所有数字的所有素数的计数。步骤如下：
- 创建最小的素因式分解数组spf []，直到数组中的最大数量。此步骤用于预先计算数字的素因子。
- 遍历给定数组arr []，并为每个元素找到spf []数组中存储的所有因子计数之和。
- 对于上述步骤中质数的幂的每个和，将其频率存储在映射中。
- 如果对于任何数字，频率都可以被K整除，则遍历地图，然后存储该数字。
- 最后，打印以上步骤中存储的所有数字。
下面是上述方法的实现：
C++
// C++ program for the above approach
#include
#include
#include
using namespace std;
// To store the smallest prime
// factor till 10^5
int spf[10001];
// Function to compute smallest
// prime factor array
void spf_array(int spf[])
{
// Initialize the spf array
// first element
spf[1] = 1;
for (int i = 2; i < 1000; i++)
// Marking smallest prime
// factor for every number
// to be itself
spf[i] = i;
// Separately marking smallest
// prime factor for every even
// number as 2
for (int i = 4; i < 1000; i += 2)
spf[i] = 2;
for (int i = 3; i * i < 1000; i++) {
// Checking if i is prime
if (spf[i] == i) {
// Marking SPF for all
// numbers divisible by i
for (int j = i * i;
j < 1000; j += i)
// Marking spf[j] if it is
// not previously marked
if (spf[j] == j)
spf[j] = i;
}
}
}
// Function that finds minimum operation
void frequent_prime(int arr[], int N,
int K)
{
// Create a spf[] array
spf_array(spf);
// Map created to store the
// unique prime numbers
unordered_map Hmap;
// To store the result
vector result;
int i = 0;
// To store minimum opeartions
int c = 0;
// To store every unique
// prime number
for (i = 0; i < N; i++) {
int x = arr[i];
while (x != 1) {
Hmap[spf[x]]
= Hmap[spf[x]] + 1;
x = x / spf[x];
}
}
// Erase 1 as a key because
// it is not a prime number
Hmap.erase(1);
for (auto x : Hmap) {
// First Prime Number
int primeNum = x.first;
int frequency = x.second;
// Frequency is divisible
// by K then insert primeNum
// in the result[]
if (frequency % K == 0) {
result.push_back(primeNum);
}
}
// Print the elements
// if it exists
if (result.size() > 0) {
for (auto& it : result) {
cout << it << ' ';
}
}
else {
cout << "{}";
}
}
// Driver Code
int main()
{
// Given array arr[]
int arr[] = { 1, 4, 6 };
// Given K
int K = 1;
int N = sizeof(arr) / sizeof(arr[0]);
// Function Call
frequent_prime(arr, N, K);
} Java
// Java program for the above approach
import java.util.*;
class GFG{
// To store the smallest prime
// factor till 10^5
static int[] spf = new int[10001];
// Function to compute smallest
// prime factor array
static void spf_array(int spf[])
{
// Initialize the spf array
// first element
spf[1] = 1;
for(int i = 2; i < 1000; i++)
// Marking smallest prime
// factor for every number
// to be itself
spf[i] = i;
// Separately marking smallest
// prime factor for every even
// number as 2
for(int i = 4; i < 1000; i += 2)
spf[i] = 2;
for(int i = 3; i * i < 1000; i++)
{
// Checking if i is prime
if (spf[i] == i)
{
// Marking SPF for all
// numbers divisible by i
for(int j = i * i;
j < 1000; j += i)
// Marking spf[j] if it is
// not previously marked
if (spf[j] == j)
spf[j] = i;
}
}
}
// Function that finds minimum operation
static void frequent_prime(int arr[], int N,
int K)
{
// Create a spf[] array
spf_array(spf);
// Map created to store the
// unique prime numbers
Map Hmap = new TreeMap<>();
// To store the result
ArrayList result = new ArrayList<>();
int i = 0;
// To store minimum opeartions
int c = 0;
// To store every unique
// prime number
for(i = 0; i < N; i++)
{
int x = arr[i];
while (x != 1)
{
Hmap.put(spf[x],
Hmap.getOrDefault(spf[x], 0) + 1);
x = x / spf[x];
}
}
// Erase 1 as a key because
// it is not a prime number
Hmap.remove(1);
for(Map.Entry x : Hmap.entrySet())
{
// First prime number
int primeNum = x.getKey();
int frequency = x.getValue();
// Frequency is divisible
// by K then insert primeNum
// in the result[]
if (frequency % K == 0)
{
result.add(primeNum);
}
}
// Print the elements
// if it exists
if (result.size() > 0)
{
for(Integer it : result)
{
System.out.print(it + " ");
}
}
else
{
System.out.print("{}");
}
}
// Driver code
public static void main (String[] args)
{
// Given array arr[]
int arr[] = { 1, 4, 6 };
// Given K
int K = 1;
int N = arr.length;
// Function call
frequent_prime(arr, N, K);
}
}
// This code is contributed by offbeat C#
// C# program for the above approach
using System;
using System.Collections.Generic;
class GFG{
// To store the smallest prime
// factor till 10^5
static int[] spf = new int[10001];
// Function to compute smallest
// prime factor array
static void spf_array(int[] spf)
{
// Initialize the spf array
// first element
spf[1] = 1;
for (int i = 2; i < 1000; i++)
// Marking smallest prime
// factor for every number
// to be itself
spf[i] = i;
// Separately marking smallest
// prime factor for every even
// number as 2
for (int i = 4; i < 1000; i += 2)
spf[i] = 2;
for (int i = 3; i * i < 1000; i++)
{
// Checking if i is prime
if (spf[i] == i)
{
// Marking SPF for all
// numbers divisible by i
for (int j = i * i; j < 1000; j += i)
// Marking spf[j] if it is
// not previously marked
if (spf[j] == j)
spf[j] = i;
}
}
}
// Function that finds minimum operation
static void frequent_prime(int[] arr, int N, int K)
{
// Create a spf[] array
spf_array(spf);
// Map created to store the
// unique prime numbers
SortedDictionary Hmap = new SortedDictionary();
// To store the result
List result = new List();
int i = 0;
// To store every unique
// prime number
for (i = 0; i < N; i++)
{
int x = arr[i];
while (x != 1)
{
if (Hmap.ContainsKey(spf[x]))
Hmap[spf[x]] = spf[x] + 1;
else
Hmap.Add(spf[x], 1);
x = x / spf[x];
}
}
// Erase 1 as a key because
// it is not a prime number
Hmap.Remove(1);
foreach(KeyValuePair x in Hmap)
{
// First prime number
int primeNum = x.Key;
int frequency = x.Value;
// Frequency is divisible
// by K then insert primeNum
// in the result[]
if (frequency % K == 0)
{
result.Add(primeNum);
}
}
// Print the elements
// if it exists
if (result.Count > 0)
{
foreach(int it in result)
{
Console.Write(it + " ");
}
}
else
{
Console.Write("{}");
}
}
// Driver code
public static void Main(String[] args)
{
// Given array []arr
int[] arr = {1, 4, 6};
// Given K
int K = 1;
int N = arr.Length;
// Function call
frequent_prime(arr, N, K);
}
}
// This code is contributed by Rajput-Ji Python3
# Python3 program for the above approach
# To store the smallest prime
# factor till 10^5
spf = [0 for i in range(10001)]
# Function to compute smallest
# prime factor array
def spf_array(spf):
# Initialize the spf array
# first element
spf[1] = 1
for i in range(2, 1000, 1):
# Marking smallest prime
# factor for every number
# to be itself
spf[i] = i
# Separately marking smallest
# prime factor for every even
# number as 2
for i in range(4, 1000, 2):
spf[i] = 2
i = 3
while( i* i < 1000):
# Checking if i is prime
if (spf[i] == i):
# Marking SPF for all
# numbers divisible by i
j = i * i
while(j < 1000):
# Marking spf[j] if it is
# not previously marked
if (spf[j] == j):
spf[j] = i
j += i
i += 1
# Function that finds minimum operation
def frequent_prime(arr, N, K):
# Create a spf[] array
spf_array(spf)
# Map created to store the
# unique prime numbers
Hmap = {}
# To store the result
result = []
i = 0
# To store minimum opeartions
c = 0
# To store every unique
# prime number
for i in range(N):
x = arr[i]
while (x != 1):
Hmap[spf[x]] = Hmap.get(spf[x], 0) + 1
x = x // spf[x]
# Erase 1 as a key because
# it is not a prime number
if (1 in Hmap):
Hmap.pop(1)
for key, value in Hmap.items():
# First Prime Number
primeNum = key
frequency = value
# Frequency is divisible
# by K then insert primeNum
# in the result[]
if (frequency % K == 0):
result.append(primeNum)
# Print the elements
# if it exists
result = result[::-1]
if (len(result) > 0):
for it in result:
print(it, end = " ")
else:
print("{}")
# Driver Code
if __name__ == '__main__':
# Given array arr[]
arr = [ 1, 4, 6 ]
# Given K
K = 1
N = len(arr)
# Function Call
frequent_prime(arr, N, K)
# This code is contributed by ipg2016107输出：
3 2
时间复杂度： O(M * log(M))，其中M是数组的最大元素。
辅助空间： O(M)