给定大小为N的数组arr [] ，任务是计算给定数组的对数，该数组的乘积仅包含一个不同的素数。
例子：
Input: arr[] = {1, 2, 3, 4}
Output: 4
Explanation:
Pairs having single distinct prime factor in their product is as follows:
arr[0] * arr[1] = (1 * 2) = 2. Therefore, the single distinct prime factor is 2.
arr[0] * arr[2] = (1 * 3) = 3. Therefore, the single distinct prime factor is 3.
arr[0] * arr[3] = (1 * 4) = 22 Therefore, the single distinct prime factor is 2.
arr[1] * arr[3] = (2 * 4) = 8 23 Therefore, the single distinct prime factor is 2.
Therefore, the required output is 4.
Input: arr[] = {2, 4, 6, 8}
Output: 3
天真的方法：解决此问题的最简单方法是遍历数组并生成数组的所有可能对，并针对每一对检查元素乘积是否仅包含单个不同的素因。如果发现为真，则增加计数。最后，打印计数。
时间复杂度： O(N 2 *√X)，其中X是给定数组中一对的最大可能乘积。
辅助空间： O(1)
高效的方法：为了优化上述方法，我们的想法是使用哈希。请按照以下步骤解决问题：
- 初始化一个变量，例如cntof1，以存储值为1的数组元素的数量。
- 创建映射，例如mp，以存储仅包含一个不同素数的数组元素的数量。
- 遍历数组，对于每个数组元素，检查不同素数的计数是否为1 。如果发现为true，则将当前元素插入mp。
- 初始化一个变量，例如res，以存储对的计数，该对的计数的元素乘积仅包含单个不同的素数。
- 遍历地图，并更新res + = cntof1 *(X)+(X *(X-1))/ 2 。其中X存储仅包含单个不同素数i的数组元素的计数。
- 最后，打印res的值。
下面是上述方法的实现
C++
// C++ program to implement
// the above approach
#include
using namespace std;
// Function to find a single
// distinct prime factor of N
int singlePrimeFactor(int N)
{
// Stores distinct
// prime factors of N
unordered_set
disPrimeFact;
// Calculate prime factor of N
for (int i = 2; i * i <= N; ++i) {
// Calculate distinct
// prime factor
while (N % i == 0) {
// Insert i into
// disPrimeFact
disPrimeFact.insert(i);
// Update N
N /= i;
}
}
// If N is not equal to 1
if (N != 1)
{
// Insert N into
// disPrimeFact
disPrimeFact.insert(N);
}
// If N contains a single
// distinct prime factor
if (disPrimeFact.size() == 1) {
// Return single distinct
// prime factor of N
return *disPrimeFact.begin();
}
// If N contains more than one
// distinct prime factor
return -1;
}
// Function to count pairs in the array
// whose product contains only
// single distinct prime factor
int cntsingleFactorPair(int arr[], int N)
{
// Stores count of 1s
// in the array
int countOf1 = 0;
// mp[i]: Stores count of array elements
// whose distinct prime factor is only i
unordered_map mp;
// Traverse the array arr[]
for (int i = 0; i < N; i++) {
// If current element is 1
if(arr[i] == 1)
{
countOf1++;
continue;
}
// Store distinct
// prime factor of arr[i]
int factorValue
= singlePrimeFactor(arr[i]);
// If arr[i] contains more
// than one prime factor
if (factorValue == -1) {
continue;
}
// If arr[i] contains
// a single prime factor
else {
mp[factorValue]++;
}
}
// Stores the count of pairs whose
// product of elements contains only
// a single distinct prime factor
int res = 0;
// Traverse the map mp[]
for (auto it : mp) {
// Stores count of array elements
// whose prime factor is (it.first)
int X = it.second;
// Update res
res += countOf1 * X +
(X * (X - 1) ) / 2;
}
return res;
}
// Driver Code
int main()
{
int arr[] = { 1, 2, 3, 4 };
int N = sizeof(arr) / sizeof(arr[0]);
cout << cntsingleFactorPair(arr, N);
return 0;
} Java
// Java program to implement
// the above approach
import java.util.*;
class GFG{
// Function to find a single
// distinct prime factor of N
static int singlePrimeFactor(int N)
{
// Stores distinct
// prime factors of N
HashSet disPrimeFact =
new HashSet<>();
// Calculate prime factor of N
for (int i = 2;
i * i <= N; ++i)
{
// Calculate distinct
// prime factor
while (N % i == 0)
{
// Insert i into
// disPrimeFact
disPrimeFact.add(i);
// Update N
N /= i;
}
}
// If N is not equal to 1
if (N != 1)
{
// Insert N into
// disPrimeFact
disPrimeFact.add(N);
}
// If N contains a single
// distinct prime factor
if (disPrimeFact.size() == 1)
{
// Return single distinct
// prime factor of N
for(int i : disPrimeFact)
return i;
}
// If N contains more than
// one distinct prime factor
return -1;
}
// Function to count pairs in
// the array whose product
// contains only single distinct
// prime factor
static int cntsingleFactorPair(int arr[],
int N)
{
// Stores count of 1s
// in the array
int countOf1 = 0;
// mp[i]: Stores count of array
// elements whose distinct prime
// factor is only i
HashMap mp = new HashMap();
// Traverse the array arr[]
for (int i = 0; i < N; i++)
{
// If current element is 1
if(arr[i] == 1)
{
countOf1++;
continue;
}
// Store distinct
// prime factor of arr[i]
int factorValue =
singlePrimeFactor(arr[i]);
// If arr[i] contains more
// than one prime factor
if (factorValue == -1)
{
continue;
}
// If arr[i] contains
// a single prime factor
else
{
if(mp.containsKey(factorValue))
mp.put(factorValue,
mp.get(factorValue) + 1);
else
mp.put(factorValue, 1);
}
}
// Stores the count of pairs whose
// product of elements contains only
// a single distinct prime factor
int res = 0;
// Traverse the map mp[]
for (Map.Entry it :
mp.entrySet())
{
// Stores count of array
// elements whose prime
// factor is (it.first)
int X = it.getValue();
// Update res
res += countOf1 * X +
(X * (X - 1) ) / 2;
}
return res;
}
// Driver Code
public static void main(String[] args)
{
int arr[] = {1, 2, 3, 4};
int N = arr.length;
System.out.print(
cntsingleFactorPair(arr, N));
}
}
// This code is contributed by gauravrajput1 Python3
# Python3 program to implement
# the above approach
# Function to find a single
# distinct prime factor of N
def singlePrimeFactor(N):
# Stores distinct
# prime factors of N
disPrimeFact = {}
# Calculate prime factor of N
for i in range(2, N + 1):
if i * i > N:
break
# Calculate distinct
# prime factor
while (N % i == 0):
# Insert i into
# disPrimeFact
disPrimeFact[i] = 1
# Update N
N //= i
# If N is not equal to 1
if (N != 1):
# Insert N into
# disPrimeFact
disPrimeFact[N] = 1
# If N contains a single
# distinct prime factor
if (len(disPrimeFact) == 1):
# Return single distinct
# prime factor of N
return list(disPrimeFact.keys())[0]
# If N contains more than one
# distinct prime factor
return -1
# Function to count pairs in the array
# whose product contains only
# single distinct prime factor
def cntsingleFactorPair(arr, N):
# Stores count of 1s
# in the array
countOf1 = 0
# mp[i]: Stores count of array elements
# whose distinct prime factor is only i
mp = {}
# Traverse the array arr[]
for i in range(N):
# If current element is 1
if (arr[i] == 1):
countOf1 += 1
continue
# Store distinct
# prime factor of arr[i]
factorValue = singlePrimeFactor(arr[i])
# If arr[i] contains more
# than one prime factor
if (factorValue == -1):
continue
# If arr[i] contains
# a single prime factor
else:
mp[factorValue] = mp.get(factorValue, 0) + 1
# Stores the count of pairs whose
# product of elements contains only
# a single distinct prime factor
res = 0
# Traverse the map mp[]
for it in mp:
# Stores count of array elements
# whose prime factor is (it.first)
X = mp[it]
# Update res
res += countOf1 * X + (X * (X - 1) ) // 2
return res
# Driver Code
if __name__ == '__main__':
arr = [ 1, 2, 3, 4 ]
N = len(arr)
print(cntsingleFactorPair(arr, N))
# This code is contributed by mohit kumar 29C#
// C# program to implement
// the above approach
using System;
using System.Collections.Generic;
class GFG{
// Function to find a single
// distinct prime factor of N
static int singlePrimeFactor(int N)
{
// Stores distinct
// prime factors of N
HashSet disPrimeFact =
new HashSet();
// Calculate prime factor of N
for (int i = 2;
i * i <= N; ++i)
{
// Calculate distinct
// prime factor
while (N % i == 0)
{
// Insert i into
// disPrimeFact
disPrimeFact.Add(i);
// Update N
N /= i;
}
}
// If N is not equal to 1
if(N != 1)
{
// Insert N into
// disPrimeFact
disPrimeFact.Add(N);
}
// If N contains a single
// distinct prime factor
if (disPrimeFact.Count == 1)
{
// Return single distinct
// prime factor of N
foreach(int i in disPrimeFact)
return i;
}
// If N contains more than
// one distinct prime factor
return -1;
}
// Function to count pairs in
// the array whose product
// contains only single distinct
// prime factor
static int cntsingleFactorPair(int []arr,
int N)
{
// Stores count of 1s
// in the array
int countOf1 = 0;
// mp[i]: Stores count of array
// elements whose distinct prime
// factor is only i
Dictionary mp =
new Dictionary();
// Traverse the array arr[]
for (int i = 0; i < N; i++)
{
// If current element is 1
if(arr[i] == 1)
{
countOf1++;
continue;
}
// Store distinct
// prime factor of arr[i]
int factorValue =
singlePrimeFactor(arr[i]);
// If arr[i] contains more
// than one prime factor
if (factorValue == -1)
{
continue;
}
// If arr[i] contains
// a single prime factor
else
{
if(mp.ContainsKey(factorValue))
mp[factorValue] = mp[factorValue] + 1;
else
mp.Add(factorValue, 1);
}
}
// Stores the count of pairs whose
// product of elements contains only
// a single distinct prime factor
int res = 0;
// Traverse the map mp[]
foreach(KeyValuePair ele1 in mp)
{
// Stores count of array
// elements whose prime
// factor is (it.first)
int X = ele1.Value;
// Update res
res += countOf1 * X +
(X * (X - 1) ) / 2;
}
return res;
}
// Driver Code
public static void Main()
{
int []arr = {1, 2, 3, 4};
int N = arr.Length;
Console.WriteLine(
cntsingleFactorPair(arr, N));
}
}
// This code is contributed by bgangwar59 输出：
4
时间复杂度： O(N√X) ，其中X是给定数组的最大元素。
辅助空间： O(N)