给定N个整数的数组arr [] 。任务是找到索引四倍数(i，j，k，l) ，以使a [i]，a [j]和a [k]在AP中，而a [j]，a [k]和a [l]在GP中。所有的四倍体必须是不同的。
例子：
Input: arr[] = {2, 6, 4, 9, 2}
Output: 2
Indexes of elements in the quadruples are (0, 2, 1, 3) and (4, 2, 1, 3) and corresponding quadruples are (2, 4, 6, 9) and (2, 4, 6, 9)
Input: arr[] = {1, 1, 1, 1}
Output: 24
天真的方法是使用四个嵌套循环来解决上述问题。检查前三个元素是否在AP中，然后检查后三个元素是否在GP中。如果两个条件都满足，那么它们将计数加1。
时间复杂度： O(n 4 )
一种有效的方法是使用组合运算法则来解决上述问题。最初，对每个数组元素的出现次数进行计数。运行两个嵌套循环，并将两个元素都视为第二个和第三个数字。因此，第一个元素为a [j] –(a [k] – a [j]) ，如果第四个元素为整数，则为a [k] * a [k] / a [j] 。因此，使用这两个索引j和k的四倍数将是第一个数的计数*第四个数的计数，而第二个和第三个元素是固定的。
下面是上述方法的实现：
C++
// C++ implementation of the approach
#include
using namespace std;
// Function to return the count of quadruples
int countQuadruples(int a[], int n)
{
// Hash table to count the number of occurrences
unordered_map mpp;
// Traverse and increment the count
for (int i = 0; i < n; i++)
mpp[a[i]]++;
int count = 0;
// Run two nested loop for second and third element
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++) {
// If they are same
if (j == k)
continue;
// Initially decrease the count
mpp[a[j]]--;
mpp[a[k]]--;
// Find the first element using common difference
int first = a[j] - (a[k] - a[j]);
// Find the fourth element using GP
// y^2 = x * z property
int fourth = (a[k] * a[k]) / a[j];
// If it is an integer
if ((a[k] * a[k]) % a[j] == 0) {
// If not equal
if (a[j] != a[k])
count += mpp[first] * mpp[fourth];
// Same elements
else
count += mpp[first] * (mpp[fourth] - 1);
}
// Later increase the value for
// future calculations
mpp[a[j]]++;
mpp[a[k]]++;
}
}
return count;
}
// Driver code
int main()
{
int a[] = { 2, 6, 4, 9, 2 };
int n = sizeof(a) / sizeof(a[0]);
cout << countQuadruples(a, n);
return 0;
} Java
// Java implementation of the approach
import java.util.*;
class GFG
{
// Function to return the count of quadruples
static int countQuadruples(int a[], int n)
{
// Hash table to count the number of occurrences
HashMap mp = new HashMap();
// Traverse and increment the count
for (int i = 0; i < n; i++)
if (mp.containsKey(a[i]))
{
mp.put(a[i], mp.get(a[i]) + 1);
}
else
{
mp.put(a[i], 1);
}
int count = 0;
// Run two nested loop for second and third element
for (int j = 0; j < n; j++)
{
for (int k = 0; k < n; k++)
{
// If they are same
if (j == k)
continue;
// Initially decrease the count
mp.put(a[j], mp.get(a[j]) - 1);
mp.put(a[k], mp.get(a[k]) - 1);
// Find the first element using common difference
int first = a[j] - (a[k] - a[j]);
// Find the fourth element using GP
// y^2 = x * z property
int fourth = (a[k] * a[k]) / a[j];
// If it is an integer
if ((a[k] * a[k]) % a[j] == 0)
{
// If not equal
if (a[j] != a[k])
{
if (mp.containsKey(first) && mp.containsKey(fourth))
count += mp.get(first) * mp.get(fourth);
}
// Same elements
else if (mp.containsKey(first) && mp.containsKey(fourth))
count += mp.get(first) * (mp.get(fourth) - 1);
}
// Later increase the value for
// future calculations
if (mp.containsKey(a[j]))
{
mp.put(a[j], mp.get(a[j]) + 1);
}
else
{
mp.put(a[j], 1);
}
if (mp.containsKey(a[k]))
{
mp.put(a[k], mp.get(a[k]) + 1);
}
else
{
mp.put(a[k], 1);
}
}
}
return count;
}
// Driver code
public static void main(String[] args)
{
int a[] = { 2, 6, 4, 9, 2 };
int n = a.length;
System.out.print(countQuadruples(a, n));
}
}
// This code is contributed by 29AjayKumar Python3
# Python3 implementation of the approach
# Function to return the count of quadruples
def countQuadruples(a, n) :
# Hash table to count the number
# of occurrences
mpp = dict.fromkeys(a, 0);
# Traverse and increment the count
for i in range(n) :
mpp[a[i]] += 1;
count = 0;
# Run two nested loop for second
# and third element
for j in range(n) :
for k in range(n) :
# If they are same
if (j == k) :
continue;
# Initially decrease the count
mpp[a[j]] -= 1;
mpp[a[k]] -= 1;
# Find the first element using
# common difference
first = a[j] - (a[k] - a[j]);
if first not in mpp :
mpp[first] = 0;
# Find the fourth element using
# GP y^2 = x * z property
fourth = (a[k] * a[k]) // a[j];
if fourth not in mpp :
mpp[fourth] = 0;
# If it is an integer
if ((a[k] * a[k]) % a[j] == 0) :
# If not equal
if (a[j] != a[k]) :
count += mpp[first] * mpp[fourth];
# Same elements
else :
count += (mpp[first] *
(mpp[fourth] - 1));
# Later increase the value for
# future calculations
mpp[a[j]] += 1;
mpp[a[k]] += 1;
return count;
# Driver code
if __name__ == "__main__" :
a = [ 2, 6, 4, 9, 2 ];
n = len(a) ;
print(countQuadruples(a, n));
# This code is contributed by RyugaC#
// C# implementation of the approach
using System;
using System.Collections.Generic;
class GFG
{
// Function to return the count of quadruples
static int countQuadruples(int []a, int n)
{
// Hash table to count the number of occurrences
Dictionary mp = new Dictionary();
// Traverse and increment the count
for (int i = 0; i < n; i++)
if (mp.ContainsKey(a[i]))
{
mp[a[i]] = mp[a[i]] + 1;
}
else
{
mp.Add(a[i], 1);
}
int count = 0;
// Run two nested loop for second and third element
for (int j = 0; j < n; j++)
{
for (int k = 0; k < n; k++)
{
// If they are same
if (j == k)
continue;
// Initially decrease the count
mp[a[j]] = mp[a[j]] - 1;
mp[a[k]] = mp[a[k]] - 1;
// Find the first element using common difference
int first = a[j] - (a[k] - a[j]);
// Find the fourth element using GP
// y^2 = x * z property
int fourth = (a[k] * a[k]) / a[j];
// If it is an integer
if ((a[k] * a[k]) % a[j] == 0)
{
// If not equal
if (a[j] != a[k])
{
if (mp.ContainsKey(first) && mp.ContainsKey(fourth))
count += mp[first] * mp[fourth];
}
// Same elements
else if (mp.ContainsKey(first) && mp.ContainsKey(fourth))
count += mp[first] * (mp[fourth] - 1);
}
// Later increase the value for
// future calculations
if (mp.ContainsKey(a[j]))
{
mp[a[j]] = mp[a[j]] + 1;
}
else
{
mp.Add(a[j], 1);
}
if (mp.ContainsKey(a[k]))
{
mp[a[k]] = mp[a[k]] + 1;
}
else
{
mp.Add(a[k], 1);
}
}
}
return count;
}
// Driver code
public static void Main(String[] args)
{
int []a = { 2, 6, 4, 9, 2 };
int n = a.Length;
Console.Write(countQuadruples(a, n));
}
}
// This code is contributed by 29AjayKumar 输出：
2
时间复杂度： O(N 2 )
辅助空间： O(N)