Open in App
Not now

# Maximize sum of count of distinct prime factors of K array elements

• Difficulty Level : Medium
• Last Updated : 06 Jul, 2021

Given an array arr[] of size N, the task is to find the maximum sum possible of the count of distinct prime factors of K array elements.

Examples:

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.

Approach: Follow the steps below to solve the problem:

• Initialize a boolean array prime[] of size 106 to store whether the number is prime or not by Sieve of Eratosthenes technique.
• Initialize an array CountDistinct[] to store the number of distinct prime factors of numbers.
• Increment the count of prime factors in its multiples, while marking the number as prime.
• Maximum number of distinct prime numbers of a number less than 106 is 8 i.e, (2 Ã— 3 Ã— 5 Ã— 7 Ã— 11 Ã— 13 Ã— 17 Ã— 19 = 9699690 > 106).
• Initialize a variable, say sum to store the maximum sum of distinct prime factors of K array elements.
• Initialize an array PrimeFactor[] of size 20 to store the count of all distinct prime factors and initialize it to 0.
• Now traverse the array arr[] and increment PrimeFactor[CountDistinct[arr[i]]]++.
• Traverse the array PrimeFactor[] from backward and increment sum up to K times till it becomes 0.

Below is the implementation of the above approach:

## 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

 ``

Output:

`4`

Time Complexity: O(N * log(log(N)))
Auxiliary Space: O(MAX)

My Personal Notes arrow_drop_up
Related Articles