找出指数总和可被 K 整除的 Array 元素的质因数

给定一个由N 个正整数组成的数组arr[]和一个整数K .，任务是创建一组素数，使得所有数组元素的素数因式分解中素数的所有幂的总和可以被K整除.

例子：

Input: arr[] = {1, 2, 3}, K = 1 
Output: {2, 3} 
Explanation: 
2 = 2¹ 
3 = 3¹ 
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 = 2¹ 
2 = 2¹ 
4 = 2² 
8 = 2³ 
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)

有效的方法：优化上述方法的想法是预先计算所有数字的所有质因子的数量。以下是步骤：

1. 创建最小的素数分解数组spf[]，直到数组中的最大数。此步骤用于预先计算一个数的质因数。
2. 遍历给定的数组arr[]并为每个元素找到存储在spf[]数组中的所有因子计数的总和。
3. 对于上述步骤中的每个素数幂的总和，将其频率存储在一个 Map 中。
4. 遍历地图，如果对于任何数字，频率可以被K整除，然后存储该数字。
5. 最后，打印上一步中存储的所有数字。

下面是上述方法的实现：

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

Javascript

 
// JavaScript program for the above approach
 
// To store the smallest prime
// factor till 10^5
var spf = Array(10001);
 
// Function to compute smallest
// prime factor array
function spf_array(spf)
{
    // Initialize the spf array
    // first element
    spf[1] = 1;
 
    for (var 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 (var i = 4; i < 1000; i += 2)
        spf[i] = 2;
 
    for (var i = 3; i * i < 1000; i++) {
 
        // Checking if i is prime
        if (spf[i] == i) {
 
            // Marking SPF for all
            // numbers divisible by i
            for (var 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
function frequent_prime(arr, N, K)
{
 
    // Create a spf[] array
    spf_array(spf);
 
    // Map created to store the
    // unique prime numbers
    var Hmap = new Map();
 
    // To store the result
    var result = [];
    var i = 0;
 
    // To store minimum opeartions
    var c = 0;
 
    // To store every unique
    // prime number
    for (i = 0; i < N; i++) {
 
        var x = arr[i];
        while (x != 1) {
 
            if(Hmap.has(spf[x]))
                Hmap.set(spf[x], Hmap.get(spf[x])+1)
            else
                Hmap.set(spf[x], 1);
            x = parseInt(x / spf[x]);
        }
    }
 
    // Erase 1 as a key because
    // it is not a prime number
    Hmap.delete(1);
 
    Hmap.forEach((value, key) => {
         
 
        // First Prime Number
        var primeNum = key;
        var frequency = value;
 
        // Frequency is divisible
        // by K then insert primeNum
        // in the result[]
        if (frequency % K == 0) {
            result.push(primeNum);
        }
    });
 
    // Print the elements
    // if it exists
    if (result.length > 0) {
        result.forEach(it => {
            document.write(it+" ");
        });
 
    }
    else {
        document.write( "{}");
    }
}
 
// Driver Code
 
// Given array arr[]
var arr = [1, 4, 6];
 
// Given K
var K = 1;
var N = arr.length;
 
// Function Call
frequent_prime(arr, N, K);
 
 

输出：

3 2

时间复杂度： O(M*log(M))，其中 M 是数组的最大元素。
辅助空间： O(M)

如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live