# Find the Number of Maximum Product Quadruples

Given an array of N positive elements find the number of quadruple, (i, j, k, m) such that i < j < k < m such that the product **a _{i}a_{j}a_{k}a_{m}** is the maximum possible

**Examples:**

Input : N = 7, arr = {1, 2, 3, 3, 3, 3, 5}Output : 4ExplanationThe maximum quadruple product possible is 135, which can be achieved by the following quadruples {i, j, k, m} such thata= 135: 1)_{i}a_{j}a_{k}a_{m}a2)_{3}a_{4}a_{5}a_{7}a3)_{3}a_{4}a_{6}a_{7}a4)_{4}a_{5}a_{6}a_{7}a_{3}a_{5}a_{6}a_{7}Input : N = 4, arr = {1, 5, 2, 1}Output : 1ExplanationThe maximum quadruple product possible is 10, which can be achieved by the following quadruple {1, 2, 3, 4} asa= 10_{1}a_{2}a_{3}a_{4}

**Brute Force: O(n ^{4})**

Generate all possible quadruples and count the quadruples giving the maximum product

**Optimized Solution**:

It is easy to see that the product of the four largest numbers would be maximum. So, the problem can now be reduced to finding the number of ways of selecting the four largest elements. To do so, maintain a frequency array which stores the frequency of each element of the array.

Suppose the largest element is X with frequency F_{X}, then if the frequency of this element is >= 4, it is best suited to select the four elements as X, X, X as this given a maximum product and the number of ways to do so are ^{FX} C _{4}

and if the frequency is less than 4, the number of ways to select this is 1 and now the required number of elements are 4 – F_{X}. For the second element, say Y, the number of ways are: ^{FX} C _{remaining_choices}. Remaining choices denotes the number of additional elements we need to select after selecting the first element. If at any time remaining_choices = 0, it means the quadruples are selected, so we can stop the algorithm

## C++

`// CPP program to find the number of Quadruples ` `// having maximum product ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// Returns the number of ways to select r objects ` `// out of available n choices ` `int` `NCR(` `int` `n, ` `int` `r) ` `{ ` ` ` `int` `numerator = 1; ` ` ` `int` `denominator = 1; ` ` ` ` ` `// ncr = (n * (n - 1) * (n - 2) * ..... ` ` ` `// ... (n - r + 1)) / (r * (r - 1) * ... * 1) ` ` ` `while` `(r > 0) { ` ` ` `numerator *= n; ` ` ` `denominator *= r; ` ` ` `n--; ` ` ` `r--; ` ` ` `} ` ` ` ` ` `return` `(numerator / denominator); ` `} ` ` ` `// Returns the number of quadruples having maximum product ` `int` `findWays(` `int` `arr[], ` `int` `n) ` `{ ` ` ` `// stores the frequency of each element ` ` ` `map<` `int` `, ` `int` `> count; ` ` ` ` ` `if` `(n < 4) ` ` ` `return` `0; ` ` ` ` ` `for` `(` `int` `i = 0; i < n; i++) { ` ` ` `count[arr[i]]++; ` ` ` `} ` ` ` ` ` `// remaining_choices denotes the remaining ` ` ` `// elements to select inorder to form quadruple ` ` ` `int` `remaining_choices = 4; ` ` ` `int` `ans = 1; ` ` ` ` ` `// traverse the elements of the map in reverse order ` ` ` `for` `(` `auto` `iter = count.rbegin(); iter != count.rend(); ++iter) { ` ` ` `int` `number = iter->first; ` ` ` `int` `frequency = iter->second; ` ` ` ` ` `// If Frequeny of element < remaining choices, ` ` ` `// select all of these elements, else select only ` ` ` `// the number of elements required ` ` ` `int` `toSelect = min(remaining_choices, frequency); ` ` ` `ans = ans * NCR(frequency, toSelect); ` ` ` ` ` `// Decrement remaining_choices acc to the number ` ` ` `// of the current elements selected ` ` ` `remaining_choices -= toSelect; ` ` ` ` ` `// if the quadruple is formed stop the algorithm ` ` ` `if` `(!remaining_choices) { ` ` ` `break` `; ` ` ` `} ` ` ` `} ` ` ` `return` `ans; ` `} ` ` ` `// Driver Code ` `int` `main() ` `{ ` ` ` `int` `arr[] = { 1, 2, 3, 3, 3, 5 }; ` ` ` `int` `n = ` `sizeof` `(arr) / ` `sizeof` `(arr[0]); ` ` ` ` ` `int` `maxQuadrupleWays = findWays(arr, n); ` ` ` `cout << maxQuadrupleWays; ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Java

`// Java program to find the number of Quadruples ` `// having maximum product ` `import` `java.util.*; ` `class` `Solution ` `{ ` `// Returns the number of ways to select r objects ` `// out of available n choices ` `static` `int` `NCR(` `int` `n, ` `int` `r) ` `{ ` ` ` `int` `numerator = ` `1` `; ` ` ` `int` `denominator = ` `1` `; ` ` ` ` ` `// ncr = (n * (n - 1) * (n - 2) * ..... ` ` ` `// ... (n - r + 1)) / (r * (r - 1) * ... * 1) ` ` ` `while` `(r > ` `0` `) { ` ` ` `numerator *= n; ` ` ` `denominator *= r; ` ` ` `n--; ` ` ` `r--; ` ` ` `} ` ` ` ` ` `return` `(numerator / denominator); ` `} ` ` ` `// Returns the number of quadruples having maximum product ` `static` `int` `findWays(` `int` `arr[], ` `int` `n) ` `{ ` ` ` `// stores the frequency of each element ` ` ` `HashMap<Integer,Integer> count= ` `new` `HashMap<Integer,Integer>(); ` ` ` ` ` `if` `(n < ` `4` `) ` ` ` `return` `0` `; ` ` ` ` ` `for` `(` `int` `i = ` `0` `; i < n; i++) { ` ` ` `count.put(arr[i],(count.get(arr[i])==` `null` `?` `0` `🙁` `int` `)count.get(arr[i]))); ` ` ` `} ` ` ` ` ` `// remaining_choices denotes the remaining ` ` ` `// elements to select inorder to form quadruple ` ` ` `int` `remaining_choices = ` `4` `; ` ` ` `int` `ans = ` `1` `; ` ` ` ` ` `// Getting an iterator ` ` ` `Iterator hmIterator = count.entrySet().iterator(); ` ` ` ` ` `while` `(hmIterator.hasNext()) { ` ` ` `Map.Entry mapElement = (Map.Entry)hmIterator.next(); ` ` ` `int` `number =(` `int` `) mapElement.getKey(); ` ` ` `int` `frequency =(` `int` `)mapElement.getValue(); ` ` ` ` ` `// If Frequeny of element < remaining choices, ` ` ` `// select all of these elements, else select only ` ` ` `// the number of elements required ` ` ` `int` `toSelect = Math.min(remaining_choices, frequency); ` ` ` `ans = ans * NCR(frequency, toSelect); ` ` ` ` ` `// Decrement remaining_choices acc to the number ` ` ` `// of the current elements selected ` ` ` `remaining_choices -= toSelect; ` ` ` ` ` `// if the quadruple is formed stop the algorithm ` ` ` `if` `(remaining_choices==` `0` `) { ` ` ` `break` `; ` ` ` `} ` ` ` `} ` ` ` ` ` `return` `ans; ` `} ` ` ` `// Driver Code ` `public` `static` `void` `main(String args[]) ` `{ ` ` ` `int` `arr[] = { ` `1` `, ` `2` `, ` `3` `, ` `3` `, ` `3` `, ` `5` `}; ` ` ` `int` `n = arr.length; ` ` ` ` ` `int` `maxQuadrupleWays = findWays(arr, n); ` ` ` `System.out.print( maxQuadrupleWays); ` `} ` `} ` `//contributed by Arnab Kundu ` |

*chevron_right*

*filter_none*

**Output:**

1

**Time Complexity:** O(NlogN), where N is sizeof the array

## Recommended Posts:

- Find the number in a range having maximum product of the digits
- Number of Quadruples with GCD equal to K
- Find four factors of N with maximum product and sum equal to N
- Find four factors of N with maximum product and sum equal to N | Set 3
- Find four factors of N with maximum product and sum equal to N | Set-2
- Find a pair with maximum product in array of Integers
- Find maximum product of digits among numbers less than or equal to N
- Maximum number with same digit factorial product
- Queries to find maximum product pair in range with updates
- Maximum of sum and product of digits until number is reduced to a single digit
- Maximum product from array such that frequency sum of all repeating elements in product is less than or equal to 2 * k
- Find sum of product of number in given series
- Find the maximum number of composite summands of a number
- Find maximum number that can be formed using digits of a given number
- Number of quadruples where the first three terms are in AP and last three terms are in GP

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.