Find the Number of Maximum Product Quadruples
Last Updated :
12 Sep, 2022
Given an array of N positive elements, find the number of quadruples, (i, j, k, m) such that i < j < k < m such that the product aiajakam is the maximum possible.
Examples:
Input : N = 7, arr = {1, 2, 3, 3, 3, 3, 5}
Output : 4
Explanation
The maximum quadruple product possible is 135, which can be
achieved by the following quadruples {i, j, k, m} such that aiajakam = 135:
1) a3a4a5a7
2) a3a4a6a7
3) a4a5a6a7
4) a3a5a6a7
Input : N = 4, arr = {1, 5, 2, 1}
Output : 1
Explanation
The maximum quadruple product possible is 10, which can be
achieved by the following quadruple {1, 2, 3, 4} as a1a2a3a4 = 10
Brute Force: O(n4)
Generate all possible quadruple 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 the maximum. So, the problem can now be reduced to finding the number of ways of selecting the four largest elements. To do so, we maintain a frequency array that stores the frequency of each element of the array.
Suppose the largest element is X with frequency FX, then if the frequency of this element is >= 4, it is best suited to select the four elements as X, X, X, as that, given a maximum product and the number of ways to do so is 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 is 4 – FX. 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, the remaining_choices = 0, it means the quadruples are selected, so we can stop the algorithm.
Implementation:
C++
#include <bits/stdc++.h>
using namespace std;
int NCR( int n, int r)
{
int numerator = 1;
int denominator = 1;
while (r > 0) {
numerator *= n;
denominator *= r;
n--;
r--;
}
return (numerator / denominator);
}
int findWays( int arr[], int n)
{
map< int , int > count;
if (n < 4)
return 0;
for ( int i = 0; i < n; i++) {
count[arr[i]]++;
}
int remaining_choices = 4;
int ans = 1;
for ( auto iter = count.rbegin(); iter != count.rend(); ++iter) {
int number = iter->first;
int frequency = iter->second;
int toSelect = min(remaining_choices, frequency);
ans = ans * NCR(frequency, toSelect);
remaining_choices -= toSelect;
if (!remaining_choices) {
break ;
}
}
return ans;
}
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;
}
|
Java
import java.util.*;
class Solution
{
static int NCR( int n, int r)
{
int numerator = 1 ;
int denominator = 1 ;
while (r > 0 ) {
numerator *= n;
denominator *= r;
n--;
r--;
}
return (numerator / denominator);
}
static int findWays( int arr[], int n)
{
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])));
}
int remaining_choices = 4 ;
int ans = 1 ;
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();
int toSelect = Math.min(remaining_choices, frequency);
ans = ans * NCR(frequency, toSelect);
remaining_choices -= toSelect;
if (remaining_choices== 0 ) {
break ;
}
}
return ans;
}
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);
}
}
|
Python3
from collections import defaultdict
def NCR(n, r):
numerator = 1
denominator = 1
while (r > 0 ):
numerator * = n
denominator * = r
n - = 1
r - = 1
return (numerator / / denominator)
def findWays(arr, n):
count = defaultdict ( int )
if (n < 4 ):
return 0
for i in range (n):
count[arr[i]] + = 1
remaining_choices = 4
ans = 1
for it in reversed ( sorted (count.keys())):
number = it
frequency = count[it]
toSelect = min (remaining_choices,
frequency)
ans = ans * NCR(frequency,
toSelect)
remaining_choices - = toSelect
if ( not remaining_choices):
break
return ans
if __name__ = = "__main__" :
arr = [ 1 , 2 , 3 , 3 , 3 , 5 ]
n = len (arr)
maxQuadrupleWays = findWays(arr, n)
print (maxQuadrupleWays)
|
C#
using System;
using System.Collections.Generic;
class GFG
{
static int NCR( int n, int r)
{
int numerator = 1;
int denominator = 1;
while (r > 0) {
numerator *= n;
denominator *= r;
n--;
r--;
}
return (numerator / denominator);
}
static int findWays( int [] arr, int n)
{
Dictionary< int , int > count
= new Dictionary< int , int >();
if (n < 4)
return 0;
for ( int i = 0; i < n; i++) {
if (!count.ContainsKey(arr[i]))
count[arr[i]] = 1;
else
count[arr[i]] += 1;
}
int remaining_choices = 4;
int ans = 1;
List< int > mapElements = new List< int >(count.Keys);
mapElements.Sort();
mapElements.Reverse();
foreach ( var number in mapElements)
{
int frequency = count[number];
int toSelect
= Math.Min(remaining_choices, frequency);
ans = ans * NCR(frequency, toSelect);
remaining_choices -= toSelect;
if (remaining_choices == 0) {
break ;
}
}
return ans;
}
public static void Main( string [] args)
{
int [] arr = { 1, 2, 3, 3, 3, 5 };
int n = arr.Length;
int maxQuadrupleWays = findWays(arr, n);
Console.WriteLine(maxQuadrupleWays);
}
}
|
Javascript
<script>
function NCR(n,r)
{
let numerator = 1;
let denominator = 1;
while (r > 0) {
numerator *= n;
denominator *= r;
n--;
r--;
}
return Math.floor(numerator / denominator);
}
function findWays(arr,n)
{
let count= new Map();
if (n < 4)
return 0;
for (let i = 0; i < n; i++) {
count.set(arr[i],(count.get(arr[i])==
null ?0:count.get(arr[i])+1));
}
let remaining_choices = 4;
let ans = 1;
for (let [key, value] of count.entries()) {
let number =key;
let frequency =value;
let toSelect = Math.min(remaining_choices, frequency);
ans = ans * NCR(frequency, toSelect);
remaining_choices -= toSelect;
if (remaining_choices==0) {
break ;
}
}
return ans;
}
let arr=[1, 2, 3, 3, 3, 5 ];
let n = arr.length;
let maxQuadrupleWays = findWays(arr, n);
document.write( maxQuadrupleWays);
</script>
|
Complexity Analysis:
- Time Complexity: O(NlogN), where N is the size of the array.
- Auxiliary Space: O(N)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...