# Count pairs from an array with even product of count of distinct prime factors

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

Given two arrays A[] and B[] consisting of N and M integers respectively, the task is to count pairs (A[i], B[j]) such that the product of their count of distinct prime factors is even.

Examples:

Input: A[] = {1, 2, 3}, B[] = {4, 5, 6}, N = 3, M = 3
Output: 2
Explanation:

• Replacing all array elements with the count of their distinct prime factors modifies the arrays to A[] = {0, 1, 1} and B[] = {1, 1, 2}.
• Therefore, total pairs with even product are {{2, 6}, {3, 6}}.

Input: A[] = {1, 7}, B[] = {5, 6}, N = 2, M = 2
Output: 1
Explanation:

• Replacing all array elements with the count of their distinct prime factors modifies the arrays to A[] = {0, 1} and B[] = {1, 2}.
• Therefore, total pairs with even product is {7, 6}.

Naive Approach: The simplest approach is to generate all possible pairs (A[i], B[j]) from both arrays and for each pair, calculate the count of distinct prime factors of the array elements and check if their product is even or not. If found to be true, then increment the count of such pairs.

Time Complexity: O(N5/2)
Auxiliary Space: O(1)

Efficient Approach: The above approach can be optimized by precalculating the count of distinct prime factors of all the numbers up to the largest element from both the arrays and use the following property of product of two numbers:

• Odd * Odd = Odd
• Even * Odd = Even
• Odd * Even = Even
• Even * Even = Even

Follow the steps below to solve the problem:

• First, calculate distinct prime factors of all numbers up to MAX and store it in vector<int> say countDistinct.
• Initialize two variables, say evenCount and oddCount, to store the count of elements with even and odd count of distinct prime factors of the array elements in B[].
• Traverse the array B[]. If, countDistinct[B[i]] = 0, skip this step. If it is odd, increment oddCount by 1. Otherwise, increment evenCount by one.
• Initialize a variable evenPairs to 0.
• Traverse the array A[] and increment evenPairs by evenCount if countDistinct[A[i]] is odd.
• Otherwise, increment evenPairs by evenCount + oddCount.
• Print the value of evenPairs.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of``// the above approach` `#include ``using` `namespace` `std;``#define MAX 1000000` `// Function to calculate count of``// distinct prime factors of a number``void` `countOfPrimefactors(vector<``int``>& CountDistinct)``{``    ``bool` `prime[MAX + 1];` `    ``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``) {``            ``CountDistinct[i] = 1;` `            ``for` `(``long` `long` `int` `j = i * 2; j <= MAX;``                 ``j += i) {` `                ``CountDistinct[j]++;``                ``prime[j] = ``false``;``            ``}``        ``}``    ``}``}` `// Function to count pairs with even``// product of distinct prime factors``int` `CountEvenPair(``int` `A[], ``int` `B[], ``int` `N, ``int` `M)``{``    ``// Stores count of``    ``// distinct prime factors``    ``vector<``int``> countDistinct(MAX + 1);` `    ``countOfPrimefactors(countDistinct);` `    ``// Stores the count of numbers``    ``// with even prime factors in B[]``    ``int` `evenCount = 0;` `    ``// Stores the count of numbers``    ``// with odd prime factors in B[]``    ``int` `oddCount = 0;` `    ``// Even Product Pairs``    ``int` `evenPairs = 0;` `    ``// Traverse the array B[]``    ``for` `(``int` `i = 0; i < M; i++) {` `        ``// Since, product has to be``        ``// positive i.e > 0` `        ``if` `(countDistinct[B[i]] == 0)``            ``continue``;` `        ``// If count of prime factors is odd``        ``if` `(countDistinct[B[i]] & 1) {` `            ``// Increment oddCount by 1``            ``oddCount++;``        ``}``        ``else` `{` `            ``// Increment evenCount by 1``            ``evenCount++;``        ``}``    ``}` `    ``for` `(``int` `i = 0; i < N; i++) {` `        ``// Since, product has to be``        ``// positive i.e > 0` `        ``if` `(countDistinct[A[i]] == 0)``            ``continue``;` `        ``// If count of prime factors is odd``        ``if` `(countDistinct[A[i]] & 1) {` `            ``// odd * even = even``            ``evenPairs += (evenCount);``        ``}` `        ``// If count of prime factors is even``        ``else` `{` `            ``// even * odd = even``            ``// even * even = even``            ``evenPairs += evenCount + oddCount;``        ``}``    ``}` `    ``return` `evenPairs;``}` `// Driver Code``int` `main()``{``    ``int` `A[] = { 1, 2, 3 };``    ``int` `B[] = { 4, 5, 6 };` `    ``int` `N = ``sizeof``(A) / ``sizeof``(A[0]);``    ``int` `M = ``sizeof``(B) / ``sizeof``(B[0]);` `    ``cout << CountEvenPair(A, B, N, M);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;` `class` `GFG``{` `  ``static` `int` `MAX = ``1000000``;` `  ``// Function to calculate count of``  ``// distinct prime factors of a number``  ``static` `void` `countOfPrimefactors(``int``[] CountDistinct)``  ``{``    ``boolean``[]  prime = ``new` `boolean``[MAX + ``1``];` `    ``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``) {``        ``CountDistinct[i] = ``1``;` `        ``for` `(``int` `j = i * ``2``; j <= MAX;``             ``j += i) {` `          ``CountDistinct[j]++;``          ``prime[j] = ``false``;``        ``}``      ``}``    ``}``  ``}` `  ``// Function to count pairs with even``  ``// product of distinct prime factors``  ``static` `int` `CountEvenPair(``int` `A[], ``int` `B[], ``int` `N, ``int` `M)``  ``{``    ``// Stores count of``    ``// distinct prime factors``    ``int``[] countDistinct = ``new` `int``[(MAX + ``1``)];` `    ``countOfPrimefactors(countDistinct);` `    ``// Stores the count of numbers``    ``// with even prime factors in B[]``    ``int` `evenCount = ``0``;` `    ``// Stores the count of numbers``    ``// with odd prime factors in B[]``    ``int` `oddCount = ``0``;` `    ``// Even Product Pairs``    ``int` `evenPairs = ``0``;` `    ``// Traverse the array B[]``    ``for` `(``int` `i = ``0``; i < M; i++) {` `      ``// Since, product has to be``      ``// positive i.e > 0` `      ``if` `(countDistinct[B[i]] == ``0``)``        ``continue``;` `      ``// If count of prime factors is odd``      ``if` `((countDistinct[B[i]] & ``1``) != ``0``) {` `        ``// Increment oddCount by 1``        ``oddCount++;``      ``}``      ``else` `{` `        ``// Increment evenCount by 1``        ``evenCount++;``      ``}``    ``}` `    ``for` `(``int` `i = ``0``; i < N; i++) {` `      ``// Since, product has to be``      ``// positive i.e > 0` `      ``if` `(countDistinct[A[i]] == ``0``)``        ``continue``;` `      ``// If count of prime factors is odd``      ``if` `((countDistinct[A[i]] & ``1``) != ``0``) {` `        ``// odd * even = even``        ``evenPairs += (evenCount);``      ``}` `      ``// If count of prime factors is even``      ``else` `{` `        ``// even * odd = even``        ``// even * even = even``        ``evenPairs += evenCount + oddCount;``      ``}``    ``}``    ``return` `evenPairs;``  ``}`  `  ``// Driver Code``  ``public` `static` `void` `main(String[] args)``  ``{``    ``int` `A[] = { ``1``, ``2``, ``3` `};``    ``int` `B[] = { ``4``, ``5``, ``6` `};` `    ``int` `N = A.length;``    ``int` `M = B.length;` `    ``System.out.println(CountEvenPair(A, B, N, M));``  ``}``}` `// This code is contributed by sanjoy_62.`

## Python3

 `# Python 3 implementation of``# the above approach``MAX` `=` `1000000` `# Function to calculate count of``# distinct prime factors of a number``def` `countOfPrimefactors(CountDistinct):``    ``global` `MAX``    ``prime ``=` `[``0` `for` `i ``in` `range``(``MAX` `+` `1``)]` `    ``for` `i ``in` `range``(``MAX``+``1``):``        ``CountDistinct[i] ``=` `0``        ``prime[i] ``=` `True` `    ``# Sieve of Eratosthenes``    ``for` `i ``in` `range``(``2``,``MAX``+``1``,``1``):``        ``if` `(prime[i] ``=``=` `True``):``            ``CountDistinct[i] ``=` `1` `            ``for` `j ``in` `range``(i ``*` `2``,``MAX``+``1``,i):``                ``CountDistinct[j] ``+``=` `1``                ``prime[j] ``=` `False``            ` `# Function to count pairs with even``# product of distinct prime factors``def` `CountEvenPair(A, B, N, M):``    ``global` `MAX``    ` `    ``# Stores count of``    ``# distinct prime factors``    ``countDistinct ``=` `[``0` `for` `i ``in` `range``(``MAX` `+` `1``)]``    ``countOfPrimefactors(countDistinct)` `    ``# Stores the count of numbers``    ``# with even prime factors in B[]``    ``evenCount ``=` `0` `    ``# Stores the count of numbers``    ``# with odd prime factors in B[]``    ``oddCount ``=` `0` `    ``# Even Product Pairs``    ``evenPairs ``=` `0` `    ``# Traverse the array B[]``    ``for` `i ``in` `range``(M):``      ` `        ``# Since, product has to be``        ``# positive i.e > 0``        ``if` `(countDistinct[B[i]] ``=``=` `0``):``            ``continue` `        ``# If count of prime factors is odd``        ``if` `(countDistinct[B[i]] & ``1``):``          ` `            ``# Increment oddCount by 1``            ``oddCount ``+``=` `1``        ` `        ``else``:``            ``# Increment evenCount by 1``            ``evenCount ``+``=` `1` `    ``for` `i ``in` `range``(N):``      ` `        ``# Since, product has to be``        ``# positive i.e > 0` `        ``if` `(countDistinct[A[i]] ``=``=` `0``):``            ``continue` `        ``# If count of prime factors is odd``        ``if` `(countDistinct[A[i]] & ``1``):``          ` `            ``# odd * even = even``            ``evenPairs ``+``=` `(evenCount)` `        ``# If count of prime factors is even``        ``else``:``            ``# even * odd = even``            ``# even * even = even``            ``evenPairs ``+``=` `evenCount ``+` `oddCount` `    ``return` `evenPairs` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``A ``=`  `[``1``, ``2``, ``3``]``    ``B ``=`  `[``4``, ``5``, ``6``]``    ``N ``=` `len``(A)``    ``M ``=` `len``(B)``    ``print``(CountEvenPair(A, B, N, M))``     ` `    ``# This code is contributed by SURENDRA_GANGWAR.`

## C#

 `// C# program for the above approach``using` `System;``public` `class` `GFG``{` `  ``static` `int` `MAX = 1000000;` `  ``// Function to calculate count of``  ``// distinct prime factors of a number``  ``static` `void` `countOfPrimefactors(``int``[] CountDistinct)``  ``{``    ``bool``[]  prime = ``new` `bool``[MAX + 1];` `    ``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``) {``        ``CountDistinct[i] = 1;` `        ``for` `(``int` `j = i * 2; j <= MAX;``             ``j += i) {` `          ``CountDistinct[j]++;``          ``prime[j] = ``false``;``        ``}``      ``}``    ``}``  ``}` `  ``// Function to count pairs with even``  ``// product of distinct prime factors``  ``static` `int` `CountEvenPair(``int` `[]A, ``int` `[]B, ``int` `N, ``int` `M)``  ``{``    ` `    ``// Stores count of``    ``// distinct prime factors``    ``int``[] countDistinct = ``new` `int``[(MAX + 1)];``    ``countOfPrimefactors(countDistinct);` `    ``// Stores the count of numbers``    ``// with even prime factors in B[]``    ``int` `evenCount = 0;` `    ``// Stores the count of numbers``    ``// with odd prime factors in B[]``    ``int` `oddCount = 0;` `    ``// Even Product Pairs``    ``int` `evenPairs = 0;` `    ``// Traverse the array B[]``    ``for` `(``int` `i = 0; i < M; i++) {` `      ``// Since, product has to be``      ``// positive i.e > 0``      ``if` `(countDistinct[B[i]] == 0)``        ``continue``;` `      ``// If count of prime factors is odd``      ``if` `((countDistinct[B[i]] & 1) != 0) {` `        ``// Increment oddCount by 1``        ``oddCount++;``      ``}``      ``else` `{` `        ``// Increment evenCount by 1``        ``evenCount++;``      ``}``    ``}` `    ``for` `(``int` `i = 0; i < N; i++) {` `      ``// Since, product has to be``      ``// positive i.e > 0` `      ``if` `(countDistinct[A[i]] == 0)``        ``continue``;` `      ``// If count of prime factors is odd``      ``if` `((countDistinct[A[i]] & 1) != 0) {` `        ``// odd * even = even``        ``evenPairs += (evenCount);``      ``}` `      ``// If count of prime factors is even``      ``else` `{` `        ``// even * odd = even``        ``// even * even = even``        ``evenPairs += evenCount + oddCount;``      ``}``    ``}``    ``return` `evenPairs;``  ``}` `  ``// Driver Code``  ``public` `static` `void` `Main(``string``[] args)``  ``{``    ``int` `[]A = { 1, 2, 3 };``    ``int` `[]B = { 4, 5, 6 };` `    ``int` `N = A.Length;``    ``int` `M = B.Length;` `    ``Console.WriteLine(CountEvenPair(A, B, N, M));``  ``}``}` `// This code is contributed by AnkThon`

## Javascript

 ``

Output:

`2`

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

My Personal Notes arrow_drop_up