 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 = { 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);` `    ``// 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``;` `    ``// 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