# Maximum product subset of an array

Given an array a, we have to find maximum product possible with the subset of elements present in the array. The maximum product can be 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

Input : a[] = { 0, 0, 0 }
Output : 0
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

A simple solution is to generate all subsets, find product of every subset and return maximum product.

A better solution is to use the below facts.

1. If there are even number of negative numbers and no zeros, result is simply product of all
2. If there are odd number of negative numbers and no zeros, result is product of all except the largest valued negative number.
3. If there are zeros, result is 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, result is 0.

Below is the implementation of avove 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, maximum valued negative number ` `    ``// 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 maximum valued negative. ` `        ``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 maximum ` `        ``// valued negative. ` `        ``prod = prod / max_neg; ` `    ``} ` ` `  `    ``return` `prod; ` `} ` ` `  `int` `main() ` `{ ` `    ``int` `a[] = {  -1, -1, -2, 4, 3  }; ` `    ``int` `n = ``sizeof``(a) / ``sizeof``(a); ` `    ``cout << maxProductSubset(a, n); ` `    ``return` `0; ` `} `

## 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, maximum valued negative number ` `        ``// 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 maximum valued negative. ` `            ``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 maximum ` `            ``// valued negative. ` `            ``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*/`

/div>

## Python3

# Python3 program to find maximum product
# of a subset.

def maxProductSubset(a, n):
if n == 1:
return a

# Find count of negative numbers, count
# of zeros, maximum valued negative
# number 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 maximum valued negative.
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 maximum
# valued negative.
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, maximum valued  ` `    ``// negative number 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 maximum valued negative. ` `        ``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 maximum ` `        ``// valued negative. ` `        ``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 maximum ` `        ``// valued negative. ` `        ``\$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 ` `?> `

Output:

```24
```

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