给定一个大小为N的数组arr[] ,任务是找到K数组元素的不同质因子的计数的最大可能总和。
例子:
Input: arr[] = {6, 9, 12}, K = 2
Output: 4
Explanation:
Distinct prime factors of 6, 9, 12 are 2, 1, 2.
K elements whose distinct prime factors are maximum are 6 and 12. Therefore, sum of their count = 2 + 2 = 4.
Input: arr[] = {4, 8, 10, 6}, K = 3
Output: 5
Explanation:
Distinct prime factors of 4, 8, 10, 6 are 1, 1, 2, 2.
K elements whose distinct prime factors are maximum are 4, 6, 10. Therefore, sum of their count = 1 + 2 + 2 = 5.
处理方法:按照以下步骤解决问题:
- 初始化一个大小为10 6的布尔数组prime[]以通过 Eratosthenes 技术来存储数字是否为素数。
- 初始化数组CountDistinct[]以存储数字的不同质因数的数量。
- 在其倍数中增加质因数的数量,同时将数字标记为质数。
- 小于10 6 的数的不同质数的最大数目为 8,即(2 × 3 × 5 × 7 × 11 × 13 × 17 × 19 = 9699690 > 10 6 )。
- 初始化一个变量,比如sum来存储K 个数组元素的不同质因子的最大和。
- 初始化大小为20的数组PrimeFactor[]以存储所有不同的素数因子的计数并将其初始化为0 。
- 现在遍历数组arr[]并递增PrimeFactor[CountDistinct[arr[i]]]++。
- 从后向遍历数组PrimeFactor[]并将 sum 递增 K 次,直到它变为 0。
下面是上述方法的实现:
C++14
// C++ program for the above approach
#include
using namespace std;
#define MAX 1000000
// Function to find the maximum sum of count
// of distinct prime factors of K array elements
int maxSumOfDistinctPrimeFactors(int arr[],
int N, int K)
{
// Stores the count of distinct primes
int CountDistinct[MAX + 1];
// Stores 1 and 0 at prime and
// non-prime indices respectively
bool prime[MAX + 1];
// Initialize the count of factors to 0
for (int i = 0; i <= MAX; i++) {
CountDistinct[i] = 0;
prime[i] = true;
}
// Sieve of Eratosthenes
for (long long int i = 2; i <= MAX; i++) {
if (prime[i] == true) {
// Count of factors of a
// prime number is 1
CountDistinct[i] = 1;
for (long long int j = i * 2; j <= MAX;
j += i) {
// Increment CountDistinct
// of all multiples of i
CountDistinct[j]++;
// Mark its multiples non-prime
prime[j] = false;
}
}
}
// Stores the maximum sum of distinct
// prime factors of K array elements
int sum = 0;
// Stores the count of all distinct
// prime factors
int PrimeFactor[20] = { 0 };
// Traverse the array to find
// count of all array elements
for (int i = 0; i < N; i++) {
PrimeFactor[CountDistinct[arr[i]]]++;
}
// Maximum sum of K prime factors
// of array elements
for (int i = 19; i >= 1; i--) {
// Check for the largest prime factor
while (PrimeFactor[i] > 0) {
// Increment sum
sum += i;
// Decrement its count and K
PrimeFactor[i]--;
K--;
if (K == 0)
break;
}
if (K == 0)
break;
}
// Print the maximum sum
cout << sum;
}
// Driver code
int main()
{
// Given array
int arr[] = { 6, 9, 12 };
// Size of the array
int N = sizeof(arr) / sizeof(arr[0]);
// Given value of K
int K = 2;
maxSumOfDistinctPrimeFactors(arr, N, K);
return 0;
}
Java
// Java program for the above approach
import java.io.*;
class GFG
{
public static int MAX = 1000000;
// Function to find the maximum sum of count
// of distinct prime factors of K array elements
static void maxSumOfDistinctPrimeFactors(int[] arr,
int N, int K)
{
// Stores the count of distinct primes
int[] CountDistinct = new int[MAX + 1];
// Stores 1 and 0 at prime and
// non-prime indices respectively
boolean[] prime = new boolean[MAX + 1];
// Initialize the count of factors to 0
for (int i = 0; i <= MAX; i++)
{
CountDistinct[i] = 0;
prime[i] = true;
}
// Sieve of Eratosthenes
for (int i = 2; i <= MAX; i++)
{
if (prime[i] == true)
{
// Count of factors of a
// prime number is 1
CountDistinct[i] = 1;
for (int j = i * 2; j <= MAX; j += i)
{
// Increment CountDistinct
// of all multiples of i
CountDistinct[j]++;
// Mark its multiples non-prime
prime[j] = false;
}
}
}
// Stores the maximum sum of distinct
// prime factors of K array elements
int sum = 0;
// Stores the count of all distinct
// prime factors
int[] PrimeFactor = new int[20];
// Traverse the array to find
// count of all array elements
for (int i = 0; i < N; i++)
{
PrimeFactor[CountDistinct[arr[i]]]++;
}
// Maximum sum of K prime factors
// of array elements
for (int i = 19; i >= 1; i--)
{
// Check for the largest prime factor
while (PrimeFactor[i] > 0)
{
// Increment sum
sum += i;
// Decrement its count and K
PrimeFactor[i]--;
K--;
if (K == 0)
break;
}
if (K == 0)
break;
}
// Print the maximum sum
System.out.print(sum);
}
// Driver code
public static void main(String[] args)
{
// Given array
int[] arr = { 6, 9, 12 };
// Size of the array
int N = arr.length;
// Given value of K
int K = 2;
maxSumOfDistinctPrimeFactors(arr, N, K);
}
}
// This code is contributed by Dharanendra L V.
Python3
# Python 3 program for the above approach
MAX = 1000000
# Function to find the maximum sum of count
# of distinct prime factors of K array elements
def maxSumOfDistinctPrimeFactors(arr, N, K):
# Stores the count of distinct primes
CountDistinct = [0]*(MAX + 1)
# Stores 1 and 0 at prime and
# non-prime indices respectively
prime = [False]*(MAX + 1)
# Initialize the count of factors to 0
for i in range(MAX + 1):
CountDistinct[i] = 0
prime[i] = True
# Sieve of Eratosthenes
for i in range(2, MAX + 1):
if (prime[i] == True):
# Count of factors of a
# prime number is 1
CountDistinct[i] = 1
for j in range(i * 2, MAX + 1, i):
# Increment CountDistinct
# of all multiples of i
CountDistinct[j] += 1
# Mark its multiples non-prime
prime[j] = False
# Stores the maximum sum of distinct
# prime factors of K array elements
sum = 0
# Stores the count of all distinct
# prime factors
PrimeFactor = [0]*20
# Traverse the array to find
# count of all array elements
for i in range(N):
PrimeFactor[CountDistinct[arr[i]]] += 1
# Maximum sum of K prime factors
# of array elements
for i in range(19, 0, -1):
# Check for the largest prime factor
while (PrimeFactor[i] > 0):
# Increment sum
sum += i
# Decrement its count and K
PrimeFactor[i] -= 1
K -= 1
if (K == 0):
break
if (K == 0):
break
# Print the maximum sum
print(sum)
# Driver code
if __name__ == "__main__":
# Given array
arr = [6, 9, 12]
# Size of the array
N = len(arr)
# Given value of K
K = 2
maxSumOfDistinctPrimeFactors(arr, N, K)
# This code is contributed by chitranayal.
C#
using System;
public class GFG {
public static int MAX = 1000000;
// Function to find the maximum sum of count
// of distinct prime factors of K array elements
static void maxSumOfDistinctPrimeFactors(int[] arr,
int N, int K)
{
// Stores the count of distinct primes
int[] CountDistinct = new int[MAX + 1];
// Stores 1 and 0 at prime and
// non-prime indices respectively
bool [] prime = new bool[MAX + 1];
// Initialize the count of factors to 0
for (int i = 0; i <= MAX; i++) {
CountDistinct[i] = 0;
prime[i] = true;
}
// Sieve of Eratosthenes
for (int i = 2; i <= MAX; i++) {
if (prime[i] == true) {
// Count of factors of a
// prime number is 1
CountDistinct[i] = 1;
for (int j = i * 2; j <= MAX; j += i) {
// Increment CountDistinct
// of all multiples of i
CountDistinct[j]++;
// Mark its multiples non-prime
prime[j] = false;
}
}
}
// Stores the maximum sum of distinct
// prime factors of K array elements
int sum = 0;
// Stores the count of all distinct
// prime factors
int[] PrimeFactor = new int[20];
// Traverse the array to find
// count of all array elements
for (int i = 0; i < N; i++) {
PrimeFactor[CountDistinct[arr[i]]]++;
}
// Maximum sum of K prime factors
// of array elements
for (int i = 19; i >= 1; i--) {
// Check for the largest prime factor
while (PrimeFactor[i] > 0) {
// Increment sum
sum += i;
// Decrement its count and K
PrimeFactor[i]--;
K--;
if (K == 0)
break;
}
if (K == 0)
break;
}
// Print the maximum sum
Console.Write(sum);
}
// Driver code
static public void Main()
{
// Given array
int[] arr = { 6, 9, 12 };
// Size of the array
int N = arr.Length;
// Given value of K
int K = 2;
maxSumOfDistinctPrimeFactors(arr, N, K);
}
}
// This code is contributed by Dharanendra L V.
Javascript
输出:
4
时间复杂度: O(N * log(log(N)))
辅助空间: O(MAX)
如果您想与行业专家一起参加直播课程,请参阅Geeks Classes Live