 Open in App
Not now

# Maximum product subset of an array

• Difficulty Level : Medium
• Last Updated : 22 Aug, 2022

Given an array a, we have to find the maximum product possible with the subset of elements present in the array. The maximum product can be a single element also.
Examples:

Input: a[] = { -1, -1, -2, 4, 3 }
Output: 24
Explanation : Maximum product will be ( -2 * -1 * 4 * 3 ) = 24

Input: a[] = { -1, 0 }
Output: 0
Explanation: 0(single element) is maximum product possible

## Maximum product subset of an array using the count of positive and negative elements

• The idea is to count the occurrence of positive and negative elements
• If there are even number of negative numbers and no zeros, the result is simply the product of all
• If there are odd number of negative numbers and no zeros,then the result is the product of all except the negative integer with the least absolute value.
• If there are zeros, the result is the product of all except these zeros with one exceptional case. The exceptional case is when there is one negative number and all other elements are 0. In this case, the result is 0.

Follow the steps mentioned below to implement the idea:

• Create 3 variables count_neg , count_zero and prod , to store the occurrence of negative elements, zeros, and the product of the subset.
• If count_neg is even then return prod.
• If count_neg is odd then divide the smallest absolute negative element from prod and return prod.
• If the array is filled with zeroes and negative elements then  return 0.

Below is the implementation of the above approach:

## C++

 `// CPP program to find maximum product of``// a subset.``#include ``using` `namespace` `std;` `int` `maxProductSubset(``int` `a[], ``int` `n)``{``    ``if` `(n == 1)``        ``return` `a;` `    ``// Find count of negative numbers, count``    ``// of zeros, negative number``    ``// with least absolute value``    ``// and product of non-zero numbers``    ``int` `max_neg = INT_MIN;``    ``int` `count_neg = 0, count_zero = 0;``    ``int` `prod = 1;``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// If number is 0, we don't``        ``// multiply it with product.``        ``if` `(a[i] == 0) {``            ``count_zero++;``            ``continue``;``        ``}` `        ``// Count negatives and keep``        ``// track of negative number``        ``// with least absolute value``        ``if` `(a[i] < 0) {``            ``count_neg++;``            ``max_neg = max(max_neg, a[i]);``        ``}` `        ``prod = prod * a[i];``    ``}` `    ``// If there are all zeros``    ``if` `(count_zero == n)``        ``return` `0;` `    ``// If there are odd number of``    ``// negative numbers``    ``if` `(count_neg & 1) {` `        ``// Exceptional case: There is only``        ``// negative and all other are zeros``        ``if` `(count_neg == 1 &&``            ``count_zero > 0 &&``            ``count_zero + count_neg == n)``            ``return` `0;` `        ``// Otherwise result is product of``        ``// all non-zeros divided by``        ``//negative number with``        ``// least absolute value``        ``prod = prod / max_neg;``    ``}` `    ``return` `prod;``}` `// Driver Code``int` `main()``{``    ``int` `a[] = {  -1, -1, -2, 4, 3  };``    ``int` `n = ``sizeof``(a) / ``sizeof``(a);``    ``cout << maxProductSubset(a, n);``    ``return` `0;``}`

## C

 `// C program to find maximum product of``// a subset.``#include ``#include``#include` `int` `maxProductSubset(``int` `a[], ``int` `n)``{``    ``if` `(n == 1)``        ``return` `a;` `    ``// Find count of negative numbers, count``    ``// of zeros, negative number``    ``// with least absolute value``    ``// and product of non-zero numbers``    ``int` `max_neg = -100000009;``    ``int` `count_neg = 0, count_zero = 0;``    ``int` `prod = 1;``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// If number is 0, we don't``        ``// multiply it with product.``        ``if` `(a[i] == 0) {``            ``count_zero++;``            ``continue``;``        ``}` `        ``// Count negatives and keep``        ``// track of negative number``        ``// with least absolute value``        ``if` `(a[i] < 0) {``            ``count_neg++;``            ``max_neg = fmax(max_neg, a[i]);``        ``}` `        ``prod = prod * a[i];``    ``}` `    ``// If there are all zeros``    ``if` `(count_zero == n)``        ``return` `0;` `    ``// If there are odd number of``    ``// negative numbers``    ``if` `(count_neg & 1) {` `        ``// Exceptional case: There is only``        ``// negative and all other are zeros``        ``if` `(count_neg == 1 &&``            ``count_zero > 0 &&``            ``count_zero + count_neg == n)``            ``return` `0;` `        ``// Otherwise result is product of``        ``// all non-zeros divided by``        ``//negative number with``        ``// least absolute value``        ``prod = prod / max_neg;``    ``}` `    ``return` `prod;``}` `// Driver Code``int` `main()``{``    ``int` `a[] = { -1, -1, -2, 4, 3 };``    ``int` `n = ``sizeof``(a) / ``sizeof``(a);``    ``printf``(``"%d"``,maxProductSubset(a, n));``    ``return` `0;``}` `// This code is contributed by rexomkar.`

## Java

 `// Java program to find maximum product of``// a subset.` `class` `GFG {` `    ``static` `int` `maxProductSubset(``int` `a[], ``int` `n) {``        ``if` `(n == ``1``) {``            ``return` `a[``0``];``        ``}` `        ``// Find count of negative numbers, count``        ``// of zeros, negative number``        ``// with least absolute value``        ``// and product of non-zero numbers``        ``int` `max_neg = Integer.MIN_VALUE;``        ``int` `count_neg = ``0``, count_zero = ``0``;``        ``int` `prod = ``1``;``        ``for` `(``int` `i = ``0``; i < n; i++) {` `            ``// If number is 0, we don't``            ``// multiply it with product.``            ``if` `(a[i] == ``0``) {``                ``count_zero++;``                ``continue``;``            ``}` `            ``// Count negatives and keep``            ``// track of negative number``            ``// with least absolute value.``            ``if` `(a[i] < ``0``) {``                ``count_neg++;``                ``max_neg = Math.max(max_neg, a[i]);``            ``}` `            ``prod = prod * a[i];``        ``}` `        ``// If there are all zeros``        ``if` `(count_zero == n) {``            ``return` `0``;``        ``}` `        ``// If there are odd number of``        ``// negative numbers``        ``if` `(count_neg % ``2` `== ``1``) {` `            ``// Exceptional case: There is only``            ``// negative and all other are zeros``            ``if` `(count_neg == ``1``                    ``&& count_zero > ``0``                    ``&& count_zero + count_neg == n) {``                ``return` `0``;``            ``}` `            ``// Otherwise result is product of``            ``// all non-zeros divided by``            ``//negative number with``            ``// least absolute value.``            ``prod = prod / max_neg;``        ``}` `        ``return` `prod;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args) {``        ``int` `a[] = {-``1``, -``1``, -``2``, ``4``, ``3``};``        ``int` `n = a.length;``        ``System.out.println(maxProductSubset(a, n));` `    ``}``}``/* This JAVA code is contributed by Rajput-Ji*/`

## Python3

 `# Python3 program to find maximum product``# of a subset.` `def` `maxProductSubset(a, n):``    ``if` `n ``=``=` `1``:``        ``return` `a[``0``]` `    ``# Find count of negative numbers, count``    ``# of zeros, negative number``    ``# with least absolute value``    ``# and product of non-zero numbers``    ``max_neg ``=` `-``999999999999``    ``count_neg ``=` `0``    ``count_zero ``=` `0``    ``prod ``=` `1``    ``for` `i ``in` `range``(n):` `        ``# If number is 0, we don't``        ``# multiply it with product.``        ``if` `a[i] ``=``=` `0``:``            ``count_zero ``+``=` `1``            ``continue` `        ``# Count negatives and keep``        ``# track of negative number``        ``# with least absolute value.``        ``if` `a[i] < ``0``:``            ``count_neg ``+``=` `1``            ``max_neg ``=` `max``(max_neg, a[i])` `        ``prod ``=` `prod ``*` `a[i]` `    ``# If there are all zeros``    ``if` `count_zero ``=``=` `n:``        ``return` `0` `    ``# If there are odd number of``    ``# negative numbers``    ``if` `count_neg & ``1``:` `        ``# Exceptional case: There is only``        ``# negative and all other are zeros``        ``if` `(count_neg ``=``=` `1` `and` `count_zero > ``0` `and``            ``count_zero ``+` `count_neg ``=``=` `n):``            ``return` `0` `        ``# Otherwise result is product of``        ``# all non-zeros divided``        ``# by negative number``        ``# with least absolute value``        ``prod ``=` `int``(prod ``/` `max_neg)` `    ``return` `prod` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``a ``=` `[ ``-``1``, ``-``1``, ``-``2``, ``4``, ``3` `]``    ``n ``=` `len``(a)``    ``print``(maxProductSubset(a, n))` `# This code is contributed by PranchalK`

## C#

 `// C# Java program to find maximum``// product of a subset.``using` `System;``                    ` `class` `GFG``{` `static` `int` `maxProductSubset(``int` `[]a,``                            ``int` `n)``{``    ``if` `(n == 1)``    ``{``        ``return` `a;``    ``}` `    ``// Find count of negative numbers,``    ``// count of zeros, negative number with``    ``// least absolute value and product of``    ``// non-zero numbers``    ``int` `max_neg = ``int``.MinValue;``    ``int` `count_neg = 0, count_zero = 0;``    ``int` `prod = 1;``    ``for` `(``int` `i = 0; i < n; i++)``    ``{` `        ``// If number is 0, we don't``        ``// multiply it with product.``        ``if` `(a[i] == 0)``        ``{``            ``count_zero++;``            ``continue``;``        ``}` `        ``// Count negatives and keep``        ``// track of negative number with``        ``// least absolute value.``        ``if` `(a[i] < 0)``        ``{``            ``count_neg++;``            ``max_neg = Math.Max(max_neg, a[i]);``        ``}` `        ``prod = prod * a[i];``    ``}` `    ``// If there are all zeros``    ``if` `(count_zero == n)``    ``{``        ``return` `0;``    ``}` `    ``// If there are odd number of``    ``// negative numbers``    ``if` `(count_neg % 2 == 1)``    ``{` `        ``// Exceptional case: There is only``        ``// negative and all other are zeros``        ``if` `(count_neg == 1 && count_zero > 0 &&``            ``count_zero + count_neg == n)``        ``{``            ``return` `0;``        ``}` `        ``// Otherwise result is product of``        ``// all non-zeros divided by negative``        ``// number with least absolute value.``        ``prod = prod / max_neg;``    ``}` `    ``return` `prod;``}` `// Driver code``public` `static` `void` `Main()``{``    ``int` `[]a = {-1, -1, -2, 4, 3};``    ``int` `n = a.Length;``    ``Console.Write(maxProductSubset(a, n));``}``}` `// This code is contributed by Rajput-Ji`

## PHP

 ` 0 &&``            ``\$count_zero` `+ ``\$count_neg` `== ``\$n``)``            ``return` `0;` `        ``// Otherwise result is product of``        ``// all non-zeros divided by negative``        ``// number with least absolute value.``        ``\$prod` `= ``\$prod` `/ ``\$max_neg``;``    ``}` `    ``return` `\$prod``;``}` `// Driver Code``\$a` `= ``array``(-1, -1, -2, 4, 3 );``\$n` `= sizeof(``\$a``);``echo` `maxProductSubset(``\$a``, ``\$n``);` `// This code is contributed``// by Akanksha Rai``?>`

## Javascript

 ``

Output

`24`

Time Complexity: O(N)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up