一对乘积等于剩余对乘积的四元组计数

给定一个大小为N的数组arr[] ，任务是计算数组中唯一四元组(a, b, c, d)的数量，使得四元组的任何一对元素的乘积等于剩下的一对元素。

例子：

Input: arr[] = {2, 3, 4, 6}
Output: 8
Explanation:
There are 8 quadruples in the array, i.e. (2, 6, 3, 4), (2, 6, 4, 3), (6, 2, 3, 4), (6, 2, 4, 3), (3, 4, 2, 6), (4, 3, 2, 6), (3, 4, 6, 2), and (4, 3, 6, 2), that satisfies the given condition.
Hence, the total number of quadruples is 8.

Input: arr[] = {1, 2, 3, 4}
Output: 0
Explanation: There exists no quadruple satisfying the given condition.

朴素的方法：最简单的方法是对遇到的每个唯一四元组使用四个嵌套循环从给定数组生成所有可能的四元组，检查它是否满足给定条件。最后，打印获得的此类三元组的计数。

时间复杂度： O(N ⁴ )
辅助空间： O(1)

高效的方法：为了优化上述方法，想法是使用Hashing。为了解决这个问题，将每个不同对的乘积存储在 Hashmap M 中。

Every quadruple (a, b, c, d) satisfying the given condition has 8 permutations:
No of ways of arranging (a, b) = 2 {(a, b), (b, a)}
No of ways of arranging (c, d) = 2 {(c, d), (d, c)}
No of ways of arranging (a, b) and (c, d) = 8 {(a, b, c, d), (a, b, d, c), (b, a, c, d), (b, a, d, c), (c, d, a, b), (c, d, b, a), (d, c, a, b), (d, c, b, a)}. 
Hence, the total no of ways = 8.

请按照以下步骤解决问题：

• 将res初始化为0以存储结果四元组的计数。
• 创建一个哈希图M来存储数组中不同对的乘积频率。
• 现在，生成给定数组的所有可能的不同对(arr[i], arr[j])并执行以下操作：
  • 将arr[i]和arr[j]的乘积存储在变量prod 中。
  • 将(8*M[prod])的值添加到变量res 。
  • 将 hashmap M中prod的频率增加1 。
• 完成以上步骤后，打印res的值作为结果。

下面是上述方法的实现：

C++

// C++ program for the above approach
#include 
using namespace std;
 
// Function to count the number of
// unique quadruples from an array
// that satisfies the given condition
void sameProductQuadruples(int nums[],
                           int N)
{
    // Hashmap to store
    // the product of pairs
    unordered_map umap;
 
    // Store the count of
    // required quadruples
    int res = 0;
 
    // Traverse the array arr[] and
    // generate all possible pairs
    for (int i = 0; i < N; ++i) {
        for (int j = i + 1; j < N; ++j) {
 
            // Store their product
            int prod = nums[i] * nums[j];
 
            // Pair(a, b) can be used to
            // generate 8 unique permutations
            // with another pair (c, d)
            res += 8 * umap[prod];
 
            // Increment um[prod] by 1
            ++umap[prod];
        }
    }
 
    // Print the result
    cout << res;
}
 
// Driver Code
int main()
{
    int arr[] = { 2, 3, 4, 6 };
    int N = sizeof(arr) / sizeof(arr[0]);
 
    sameProductQuadruples(arr, N);
 
    return 0;
}

Java

// Java program for the above approach
import java.io.*;
import java.util.*;
class GFG
{
   
// Function to count the number of
// unique quadruples from an array
// that satisfies the given condition
static void sameProductQuadruples(int[] nums,
                           int N)
{
    // Hashmap to store
    // the product of pairs
    int[] umap = new int[10000];
     
    // Store the count of
    // required quadruples
    int res = 0;
 
    // Traverse the array arr[] and
    // generate all possible pairs
    for (int i = 0; i < N; ++i)
    {
        for (int j = i + 1; j < N; ++j)
        {
 
            // Store their product
            int prod = nums[i] * nums[j];
 
            // Pair(a, b) can be used to
            // generate 8 unique permutations
            // with another pair (c, d)
            res += 8 * umap[prod];
 
            // Increment um[prod] by 1
            ++umap[prod];
        }
    }
 
    // Print the result
     System.out.println(res);
}
 
 
// Driver Code
public static void main(String[] args)
{
    int[] arr = { 2, 3, 4, 6 };
    int N = arr.length;
 
    sameProductQuadruples(arr, N);
}
}
 
// This code is contributed by code_hunt.

Python3

# Python program for the above approach
 
# Function to count the number of
# unique quadruples from an array
# that satisfies the given condition
def sameProductQuadruples(nums, N) :
 
    # Hashmap to store
    # the product of pairs
    umap = {};
 
    # Store the count of
    # required quadruples
    res = 0;
 
    # Traverse the array arr[] and
    # generate all possible pairs
    for i in range(N) :
        for j in range(i + 1, N) :
 
            # Store their product
            prod = nums[i] * nums[j];   
            if prod in umap :
                 
                # Pair(a, b) can be used to
                # generate 8 unique permutations
                # with another pair (c, d)
                res += 8 * umap[prod];
     
                # Increment umap[prod] by 1
                umap[prod] += 1;
            else:
                umap[prod] = 1
 
    # Print the result
    print(res);
 
# Driver Code
if __name__ == "__main__" :
 
    arr = [ 2, 3, 4, 6 ];
    N = len(arr);
 
    sameProductQuadruples(arr, N);
 
    # This code is contributed by AnkThon

C#

// C# program to implement
// the above approach
using System;
 
class GFG
{
 
// Function to count the number of
// unique quadruples from an array
// that satisfies the given condition
static void sameProductQuadruples(int[] nums,
                           int N)
{
    // Hashmap to store
    // the product of pairs
    int[] umap = new int[10000];
     
    // Store the count of
    // required quadruples
    int res = 0;
 
    // Traverse the array arr[] and
    // generate all possible pairs
    for (int i = 0; i < N; ++i)
    {
        for (int j = i + 1; j < N; ++j)
        {
 
            // Store their product
            int prod = nums[i] * nums[j];
 
            // Pair(a, b) can be used to
            // generate 8 unique permutations
            // with another pair (c, d)
            res += 8 * umap[prod];
 
            // Increment um[prod] by 1
            ++umap[prod];
        }
    }
 
    // Print the result
    Console.Write(res);
}
 
// Driver Code
public static void Main(String[] args)
{
    int[] arr = { 2, 3, 4, 6 };
    int N = arr.Length;
 
    sameProductQuadruples(arr, N);
}
}
 
// This code is contributed by sanjoy_62.

Javascript

      // JavaScript program to implement
      // the above approach
      // Function to count the number of
      // unique quadruples from an array
      // that satisfies the given condition
      function sameProductQuadruples(nums, N) {
        // Hashmap to store
        // the product of pairs
        var umap = new Array(10000).fill(0);
 
        // Store the count of
        // required quadruples
        var res = 0;
 
        // Traverse the array arr[] and
        // generate all possible pairs
        for (var i = 0; i < N; ++i) {
          for (var j = i + 1; j < N; ++j) {
            // Store their product
            var prod = nums[i] * nums[j];
 
            // Pair(a, b) can be used to
            // generate 8 unique permutations
            // with another pair (c, d)
            res += 8 * umap[prod];
 
            // Increment um[prod] by 1
            ++umap[prod];
          }
        }
 
        // Print the result
        document.write(res);
      }
 
      // Driver Code
      var arr = [2, 3, 4, 6];
      var N = arr.length;
 
      sameProductQuadruples(arr, N);

输出：

8

时间复杂度： O(N ² )
辅助空间： O(N ² )

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。