 Open in App
Not now

# Maximum Product Subarray

• Difficulty Level : Hard
• Last Updated : 21 Dec, 2022

Given an array that contains both positive and negative integers, find the product of the maximum product subarray.

Examples:

Input: arr[] = {6, -3, -10, 0, 2}
Output:   180  // The subarray is {6, -3, -10}

Input: arr[] = {-1, -3, -10, 0, 60}
Output:   60  // The subarray is {60} Naive Approach: To solve the problem follow the below idea:

The idea is to traverse over every contiguous subarray, find the product of each of these subarrays and return the maximum product from these results.

Follow the below steps to solve the problem:

• Run a nested for loop to generate every subarray
• Calculate the product of elements in the current subarray
• Return the maximum of these products calculated from the subarrays

Below is the implementation of the above approach:

## C++

 `// C++ program to find Maximum Product Subarray``#include ``using` `namespace` `std;` `/* Returns the product of max product subarray.*/``int` `maxSubarrayProduct(``int` `arr[], ``int` `n)``{``    ``// Initializing result``    ``int` `result = arr;` `    ``for` `(``int` `i = 0; i < n; i++) {``        ``int` `mul = arr[i];``        ``// traversing in current subarray``        ``for` `(``int` `j = i + 1; j < n; j++) {``            ``// updating result every time``            ``// to keep an eye over the maximum product``            ``result = max(result, mul);``            ``mul *= arr[j];``        ``}``        ``// updating the result for (n-1)th index.``        ``result = max(result, mul);``    ``}``    ``return` `result;``}` `// Driver code``int` `main()``{``    ``int` `arr[] = { 1, -2, -3, 0, 7, -8, -2 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);``    ``cout << ``"Maximum Sub array product is "``         ``<< maxSubarrayProduct(arr, n);``    ``return` `0;``}` `// This code is contributed by Aditya Kumar (adityakumar129)`

## C

 `// C program to find Maximum Product Subarray``#include ` `// Find maximum between two numbers.``int` `max(``int` `num1, ``int` `num2)``{``    ``return` `(num1 > num2) ? num1 : num2;``}` `/* Returns the product of max product subarray.*/``int` `maxSubarrayProduct(``int` `arr[], ``int` `n)``{``    ``// Initializing result``    ``int` `result = arr;` `    ``for` `(``int` `i = 0; i < n; i++) {``        ``int` `mul = arr[i];``        ``// traversing in current subarray``        ``for` `(``int` `j = i + 1; j < n; j++) {``            ``// updating result every time``            ``// to keep an eye over the maximum product``            ``result = max(result, mul);``            ``mul *= arr[j];``        ``}``        ``// updating the result for (n-1)th index.``        ``result = max(result, mul);``    ``}``    ``return` `result;``}` `// Driver code``int` `main()``{``    ``int` `arr[] = { 1, -2, -3, 0, 7, -8, -2 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);``    ``printf``(``"Maximum Sub array product is %d "``,``           ``maxSubarrayProduct(arr, n));``    ``return` `0;``}` `// This code is contributed by Aditya Kumar (adityakumar129)`

## Java

 `// Java program to find maximum product subarray``import` `java.io.*;` `class` `GFG {``    ``/* Returns the product of max product subarray.*/``    ``static` `int` `maxSubarrayProduct(``int` `arr[])``    ``{``        ``// Initializing result``        ``int` `result = arr[``0``];``        ``int` `n = arr.length;` `        ``for` `(``int` `i = ``0``; i < n; i++) {``            ``int` `mul = arr[i];``            ``// traversing in current subarray``            ``for` `(``int` `j = i + ``1``; j < n; j++) {``                ``// updating result every time to keep an eye``                ``// over the maximum product``                ``result = Math.max(result, mul);``                ``mul *= arr[j];``            ``}``            ``// updating the result for (n-1)th index.``            ``result = Math.max(result, mul);``        ``}``        ``return` `result;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `arr[] = { ``1``, -``2``, -``3``, ``0``, ``7``, -``8``, -``2` `};``        ``System.out.println(``"Maximum Sub array product is "``                           ``+ maxSubarrayProduct(arr));``    ``}``}` `// This code is contributed by Aditya Kumar (adityakumar129)`

## Python3

 `# Python3 program to find Maximum Product Subarray` `# Returns the product of max product subarray.`  `def` `maxSubarrayProduct(arr, n):` `    ``# Initializing result``    ``result ``=` `arr[``0``]` `    ``for` `i ``in` `range``(n):` `        ``mul ``=` `arr[i]` `        ``# traversing in current subarray``        ``for` `j ``in` `range``(i ``+` `1``, n):` `            ``# updating result every time``            ``# to keep an eye over the maximum product``            ``result ``=` `max``(result, mul)``            ``mul ``*``=` `arr[j]` `        ``# updating the result for (n-1)th index.``        ``result ``=` `max``(result, mul)` `    ``return` `result`  `# Driver code``arr ``=` `[``1``, ``-``2``, ``-``3``, ``0``, ``7``, ``-``8``, ``-``2``]``n ``=` `len``(arr)``print``(``"Maximum Sub array product is"``, maxSubarrayProduct(arr, n))` `# This code is contributed by divyeshrabadiya07`

## C#

 `// C# program to find maximum product subarray``using` `System;` `class` `GFG {` `    ``// Returns the product of max product subarray``    ``static` `int` `maxSubarrayProduct(``int``[] arr)``    ``{` `        ``// Initializing result``        ``int` `result = arr;``        ``int` `n = arr.Length;` `        ``for` `(``int` `i = 0; i < n; i++) {``            ``int` `mul = arr[i];` `            ``// Traversing in current subarray``            ``for` `(``int` `j = i + 1; j < n; j++) {` `                ``// Updating result every time``                ``// to keep an eye over the``                ``// maximum product``                ``result = Math.Max(result, mul);``                ``mul *= arr[j];``            ``}` `            ``// Updating the result for (n-1)th index``            ``result = Math.Max(result, mul);``        ``}``        ``return` `result;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``int``[] arr = { 1, -2, -3, 0, 7, -8, -2 };` `        ``Console.Write(``"Maximum Sub array product is "``                      ``+ maxSubarrayProduct(arr));``    ``}``}` `// This code is contributed by shivanisinghss2110`

## Javascript

 ``

Output

`Maximum Sub array product is 112`

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

Efficient Approach: To solve the problem follow the below idea:

The following solution assumes that the given input array always has a positive output. The solution works for all cases mentioned above. It doesn’t work for arrays like {0, 0, -20, 0}, {0, 0, 0}.. etc. The solution can be easily modified to handle this case. It is similar to the Largest Sum Contiguous Subarray problem.

The only thing to note here is, the maximum product can also be obtained by the minimum (negative) product ending with the previous element multiplied by this element. For example, in array {12, 2, -3, -5, -6, -2}, when we are at element -2, the maximum product is the multiplication of, the minimum product ending with -6 and -2

Note: if all elements of the array are negative then the maximum product with the above algorithm is 1. so, if the maximum product is 1, then we have to return the maximum element of an array

Follow the below steps to solve the problem:

• Declare two integers max_ending _here and min_ending_here equal to one and max_so_far equal to zero
• Run a for loop for i [0, N]
• If the current element is greater than zero
• Set max_ending_here equal to max_ending_here * arr[i]
• Set min_ending_here equal to the minimum of min_ending_here * arr[i] and 1
• Set a boolean flag equal to one
• Else if the current element is equal to zero
• Set both max_ending_here and min_ending_here equal to one
• Else
• Set max_ending here equal to the maximum of min_ending_here * arr[i] and 1
• Set min_ending_here equal to max_ending_here * arr[i]
• If max_ending_here is greater than max_so_far then update max_so_far
• If the flag is equal to zero then return zero
• If the max_so_far is equal to one i.e all array elements are negative the return maximum element in the input array
• Return max_so_far

Below is the implementation of the above approach:

## C++

 `// C++ program to find Maximum Product Subarray``#include ``using` `namespace` `std;` `/* Returns the product``  ``of max product subarray.``  ``*/``int` `maxSubarrayProduct(``int` `arr[], ``int` `n)``{``    ``// max positive product``    ``// ending at the current position``    ``int` `max_ending_here = 1;` `    ``// min negative product ending``    ``// at the current position``    ``int` `min_ending_here = 1;` `    ``// Initialize overall max product``    ``int` `max_so_far = 0;``    ``int` `flag = 0;``    ``/* Traverse through the array.``    ``Following values are``    ``maintained after the i'th iteration:``    ``max_ending_here is always 1 or``    ``some positive product ending with arr[i]``    ``min_ending_here is always 1 or``    ``some negative product ending with arr[i] */``    ``for` `(``int` `i = 0; i < n; i++) {``        ``/* If this element is positive, update``        ``max_ending_here. Update min_ending_here only if``        ``min_ending_here is negative */``        ``if` `(arr[i] > 0) {``            ``max_ending_here = max_ending_here * arr[i];``            ``min_ending_here``                ``= min(min_ending_here * arr[i], 1);``            ``flag = 1;``        ``}` `        ``/* If this element is 0, then the maximum product``        ``cannot end here, make both max_ending_here and``        ``min_ending_here 0``        ``Assumption: Output is always greater than or equal``                    ``to 1. */``        ``else` `if` `(arr[i] == 0) {``            ``max_ending_here = 1;``            ``min_ending_here = 1;``        ``}` `        ``/* If element is negative. This is tricky``         ``max_ending_here can either be 1 or positive.``         ``min_ending_here can either be 1 or negative.``         ``next max_ending_here will always be prev.``         ``min_ending_here * arr[i] ,next min_ending_here``         ``will be 1 if prev max_ending_here is 1, otherwise``         ``next min_ending_here will be prev max_ending_here *``         ``arr[i] */` `        ``else` `{``            ``int` `temp = max_ending_here;``            ``max_ending_here``                ``= max(min_ending_here * arr[i], 1);``            ``min_ending_here = temp * arr[i];``        ``}` `        ``// update max_so_far, if needed``        ``if` `(max_so_far < max_ending_here)``            ``max_so_far = max_ending_here;``    ``}``    ``if` `(flag == 0 && max_so_far == 0)``        ``return` `0;``    ``/* if all the array elements are negative */``    ``if` `(max_so_far == 1) {``        ``max_so_far = arr;``        ``for` `(``int` `i = 1; i < n; i++)``            ``max_so_far = max(max_so_far, arr[i]);``    ``}``    ``return` `max_so_far;``}` `// Driver code``int` `main()``{``    ``int` `arr[] = { 1, -2, -3, 0, 7, -8, -2 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);``    ``cout << ``"Maximum Sub array product is "``         ``<< maxSubarrayProduct(arr, n);``    ``return` `0;``}` `// This is code is contributed by rathbhupendra`

## C

 `// C program to find Maximum Product Subarray``#include ` `// Utility functions to get minimum of two integers``int` `min(``int` `x, ``int` `y) { ``return` `x < y ? x : y; }` `// Utility functions to get maximum of two integers``int` `max(``int` `x, ``int` `y) { ``return` `x > y ? x : y; }` `/* Returns the product of max product subarray.``Assumes that the given array always has a subarray``with product more than 1 */``int` `maxSubarrayProduct(``int` `arr[], ``int` `n)``{``    ``// max positive product``    ``// ending at the current position``    ``int` `max_ending_here = 1;` `    ``// min negative product ending``    ``// at the current position``    ``int` `min_ending_here = 1;` `    ``// Initialize overall max product``    ``int` `max_so_far = 0;``    ``int` `flag = 0;` `    ``/* Traverse through the array. Following values are``    ``maintained after the i'th iteration:``    ``max_ending_here is always 1 or some positive product``                    ``ending with arr[i]``    ``min_ending_here is always 1 or some negative product``                    ``ending with arr[i] */``    ``for` `(``int` `i = 0; i < n; i++) {``        ``/* If this element is positive, update``        ``max_ending_here. Update min_ending_here only if``        ``min_ending_here is negative */``        ``if` `(arr[i] > 0) {``            ``max_ending_here = max_ending_here * arr[i];``            ``min_ending_here``                ``= min(min_ending_here * arr[i], 1);``            ``flag = 1;``        ``}` `        ``/* If this element is 0, then the maximum product``        ``cannot end here, make both max_ending_here and``        ``min_ending_here 0``        ``Assumption: Output is alway greater than or equal``                    ``to 1. */``        ``else` `if` `(arr[i] == 0) {``            ``max_ending_here = 1;``            ``min_ending_here = 1;``        ``}` `        ``/* If element is negative. This is tricky``        ``max_ending_here can either be 1 or positive.``        ``min_ending_here can either be 1 or negative.``        ``next min_ending_here will always be prev.``        ``max_ending_here * arr[i] next max_ending_here``        ``will be 1 if prev min_ending_here is 1, otherwise``        ``next max_ending_here will be prev min_ending_here *``        ``arr[i] */``        ``else` `{``            ``int` `temp = max_ending_here;``            ``max_ending_here``                ``= max(min_ending_here * arr[i], 1);``            ``min_ending_here = temp * arr[i];``        ``}` `        ``// update max_so_far, if needed``        ``if` `(max_so_far < max_ending_here)``            ``max_so_far = max_ending_here;``    ``}``    ``if` `(flag == 0 && max_so_far == 0)``        ``return` `0;``    ``return` `max_so_far;` `    ``return` `max_so_far;``}` `// Driver code``int` `main()``{``    ``int` `arr[] = { 1, -2, -3, 0, 7, -8, -2 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);``    ``printf``(``"Maximum Sub array product is %d"``,``           ``maxSubarrayProduct(arr, n));``    ``return` `0;``}`

## Java

 `// Java program to find maximum product subarray``import` `java.io.*;` `class` `ProductSubarray {` `    ``// Utility functions to get``    ``// minimum of two integers``    ``static` `int` `min(``int` `x, ``int` `y) { ``return` `x < y ? x : y; }` `    ``// Utility functions to get``    ``// maximum of two integers``    ``static` `int` `max(``int` `x, ``int` `y) { ``return` `x > y ? x : y; }` `    ``/* Returns the product of``    ``max product subarray.``    ``Assumes that the given``    ``array always has a subarray``    ``with product more than 1 */``    ``static` `int` `maxSubarrayProduct(``int` `arr[])``    ``{``        ``int` `n = arr.length;``        ``// max positive product``        ``// ending at the current``        ``// position``        ``int` `max_ending_here = ``1``;` `        ``// min negative product``        ``// ending at the current``        ``// position``        ``int` `min_ending_here = ``1``;` `        ``// Initialize overall max product``        ``int` `max_so_far = ``0``;``        ``int` `flag = ``0``;` `        ``/* Traverse through the array. Following``        ``values are maintained after the ith iteration:``        ``max_ending_here is always 1 or some positive product``                        ``ending with arr[i]``        ``min_ending_here is always 1 or some negative product``                        ``ending with arr[i] */``        ``for` `(``int` `i = ``0``; i < n; i++) {``            ``/* If this element is positive, update``               ``max_ending_here. Update min_ending_here only``               ``if min_ending_here is negative */``            ``if` `(arr[i] > ``0``) {``                ``max_ending_here = max_ending_here * arr[i];``                ``min_ending_here``                    ``= min(min_ending_here * arr[i], ``1``);``                ``flag = ``1``;``            ``}` `            ``/* If this element is 0, then the maximum``            ``product cannot end here, make both``            ``max_ending_here and min_ending _here 0``            ``Assumption: Output is always greater than or``            ``equal to 1. */``            ``else` `if` `(arr[i] == ``0``) {``                ``max_ending_here = ``1``;``                ``min_ending_here = ``1``;``            ``}` `            ``/* If element is negative. This is tricky``            ``max_ending_here can either be 1 or positive.``            ``min_ending_here can either be 1 or negative.``            ``next min_ending_here will always be prev.``            ``max_ending_here * arr[i]``            ``next max_ending_here will be 1 if prev``            ``min_ending_here is 1, otherwise``            ``next max_ending_here will be``                        ``prev min_ending_here * arr[i] */``            ``else` `{``                ``int` `temp = max_ending_here;``                ``max_ending_here``                    ``= max(min_ending_here * arr[i], ``1``);``                ``min_ending_here = temp * arr[i];``            ``}` `            ``// update max_so_far, if needed``            ``if` `(max_so_far < max_ending_here)``                ``max_so_far = max_ending_here;``        ``}` `        ``if` `(flag == ``0` `&& max_so_far == ``0``)``            ``return` `0``;``        ``return` `max_so_far;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{` `        ``int` `arr[] = { ``1``, -``2``, -``3``, ``0``, ``7``, -``8``, -``2` `};``        ``System.out.println(``"Maximum Sub array product is "``                           ``+ maxSubarrayProduct(arr));``    ``}``} ``/*This code is contributed by Devesh Agrawal*/`

## Python3

 `# Python program to find maximum product subarray` `# Returns the product of max product subarray.``# Assumes that the given array always has a subarray``# with product more than 1`  `def` `maxsubarrayproduct(arr):` `    ``n ``=` `len``(arr)` `    ``# max positive product ending at the current position``    ``max_ending_here ``=` `1` `    ``# min positive product ending at the current position``    ``min_ending_here ``=` `1` `    ``# Initialize maximum so far``    ``max_so_far ``=` `0``    ``flag ``=` `0` `    ``# Traverse throughout the array. Following values``    ``# are maintained after the ith iteration:``    ``# max_ending_here is always 1 or some positive product``    ``# ending with arr[i]``    ``# min_ending_here is always 1 or some negative product``    ``# ending with arr[i]``    ``for` `i ``in` `range``(``0``, n):` `        ``# If this element is positive, update max_ending_here.``        ``# Update min_ending_here only if min_ending_here is``        ``# negative``        ``if` `arr[i] > ``0``:``            ``max_ending_here ``=` `max_ending_here ``*` `arr[i]``            ``min_ending_here ``=` `min``(min_ending_here ``*` `arr[i], ``1``)``            ``flag ``=` `1` `        ``# If this element is 0, then the maximum product cannot``        ``# end here, make both max_ending_here and min_ending_here 0``        ``# Assumption: Output is alway greater than or equal to 1.``        ``elif` `arr[i] ``=``=` `0``:``            ``max_ending_here ``=` `1``            ``min_ending_here ``=` `1` `        ``# If element is negative. This is tricky``        ``# max_ending_here can either be 1 or positive.``        ``# min_ending_here can either be 1 or negative.``        ``# next min_ending_here will always be prev.``        ``# max_ending_here * arr[i]``        ``# next max_ending_here will be 1 if prev``        ``# min_ending_here is 1, otherwise``        ``# next max_ending_here will be prev min_ending_here * arr[i]``        ``else``:``            ``temp ``=` `max_ending_here``            ``max_ending_here ``=` `max``(min_ending_here ``*` `arr[i], ``1``)``            ``min_ending_here ``=` `temp ``*` `arr[i]``        ``if` `(max_so_far < max_ending_here):``            ``max_so_far ``=` `max_ending_here` `    ``if` `flag ``=``=` `0` `and` `max_so_far ``=``=` `0``:``        ``return` `0``    ``return` `max_so_far`  `# Driver function to test above function``arr ``=` `[``1``, ``-``2``, ``-``3``, ``0``, ``7``, ``-``8``, ``-``2``]``print``(``"Maximum product subarray is"``, maxsubarrayproduct(arr))` `# This code is contributed by Devesh Agrawal`

## C#

 `// C# program to find maximum product subarray``using` `System;` `class` `GFG {` `    ``// Utility functions to get minimum of two integers``    ``static` `int` `min(``int` `x, ``int` `y) { ``return` `x < y ? x : y; }` `    ``// Utility functions to get maximum of two integers``    ``static` `int` `max(``int` `x, ``int` `y) { ``return` `x > y ? x : y; }` `    ``/* Returns the product of max product subarray.``    ``Assumes that the given array always has a subarray``    ``with product more than 1 */``    ``static` `int` `maxSubarrayProduct(``int``[] arr)``    ``{``        ``int` `n = arr.Length;``        ``// max positive product ending at the current``        ``// position``        ``int` `max_ending_here = 1;` `        ``// min negative product ending at the current``        ``// position``        ``int` `min_ending_here = 1;` `        ``// Initialize overall max product``        ``int` `max_so_far = 0;``        ``int` `flag = 0;` `        ``/* Traverse through the array. Following``        ``values are maintained after the ith iteration:``        ``max_ending_here is always 1 or some positive``        ``product ending with arr[i] min_ending_here is``        ``always 1 or some negative product ending``        ``with arr[i] */``        ``for` `(``int` `i = 0; i < n; i++) {``            ``/* If this element is positive, update``            ``max_ending_here. Update min_ending_here``            ``only if min_ending_here is negative */``            ``if` `(arr[i] > 0) {``                ``max_ending_here = max_ending_here * arr[i];``                ``min_ending_here``                    ``= min(min_ending_here * arr[i], 1);``                ``flag = 1;``            ``}` `            ``/* If this element is 0, then the maximum``            ``product cannot end here, make both``            ``max_ending_here and min_ending_here 0``            ``Assumption: Output is alway greater than or``            ``equal to 1. */``            ``else` `if` `(arr[i] == 0) {``                ``max_ending_here = 1;``                ``min_ending_here = 1;``            ``}` `            ``/* If element is negative. This is tricky``            ``max_ending_here can either be 1 or positive.``            ``min_ending_here can either be 1 or negative.``            ``next min_ending_here will always be prev.``            ``max_ending_here * arr[i]``            ``next max_ending_here will be 1 if prev``            ``min_ending_here is 1, otherwise``            ``next max_ending_here will be``            ``prev min_ending_here * arr[i] */``            ``else` `{``                ``int` `temp = max_ending_here;``                ``max_ending_here``                    ``= max(min_ending_here * arr[i], 1);``                ``min_ending_here = temp * arr[i];``            ``}` `            ``// update max_so_far, if needed``            ``if` `(max_so_far < max_ending_here)``                ``max_so_far = max_ending_here;``        ``}` `        ``if` `(flag == 0 && max_so_far == 0)``            ``return` `0;` `        ``return` `max_so_far;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main()``    ``{` `        ``int``[] arr = { 1, -2, -3, 0, 7, -8, -2 };` `        ``Console.WriteLine(``"Maximum Sub array product is "``                          ``+ maxSubarrayProduct(arr));``    ``}``}` `/*This code is contributed by vt_m*/`

## PHP

 ` ``\$y``? ``\$x` `: ``\$y``;``}` `/* Returns the product of max product``subarray. Assumes that the given array``always has a subarray with product``more than 1 */``function` `maxSubarrayProduct(``\$arr``, ``\$n``)``{``    ` `    ``// max positive product ending at``    ``// the current position``    ``\$max_ending_here` `= 1;` `    ``// min negative product ending at``    ``// the current position``    ``\$min_ending_here` `= 1;` `    ``// Initialize overall max product``    ``\$max_so_far` `= 0;``    ``\$flag` `= 0;` `    ``/* Traverse through the array.``    ``Following values are maintained``    ``after the i'th iteration:``    ``max_ending_here is always 1 or``    ``some positive product ending with``    ``arr[i] min_ending_here is always``    ``1 or some negative product ending``    ``with arr[i] */``    ``for` `(``\$i` `= 0; ``\$i` `< ``\$n``; ``\$i``++)``    ``{``        ` `        ``/* If this element is positive,``        ``update max_ending_here. Update``        ``min_ending_here only if``        ``min_ending_here is negative */``        ``if` `(``\$arr``[``\$i``] > 0)``        ``{``            ``\$max_ending_here` `=``            ``\$max_ending_here` `* ``\$arr``[``\$i``];``            ` `            ``\$min_ending_here` `=``                ``min (``\$min_ending_here``                        ``* ``\$arr``[``\$i``], 1);``            ``\$flag` `= 1;``        ``}` `        ``/* If this element is 0, then the``        ``maximum product cannot end here,``        ``make both max_ending_here and``        ``min_ending_here 0``        ``Assumption: Output is alway``        ``greater than or equal to 1. */``        ``else` `if` `(``\$arr``[``\$i``] == 0)``        ``{``            ``\$max_ending_here` `= 1;``            ``\$min_ending_here` `= 1;``        ``}` `        ``/* If element is negative. This``        ``is tricky max_ending_here can``        ``either be 1 or positive.``        ``min_ending_here can either be 1 or``        ``negative. next min_ending_here will``        ``always be prev. max_ending_here *``        ``arr[i] next max_ending_here will be``        ``1 if prev min_ending_here is 1,``        ``otherwise next max_ending_here will``        ``be prev min_ending_here * arr[i] */``        ``else``        ``{``            ``\$temp` `= ``\$max_ending_here``;``            ``\$max_ending_here` `=``                ``max (``\$min_ending_here``                        ``* ``\$arr``[``\$i``], 1);``                            ` `            ``\$min_ending_here` `=``                        ``\$temp` `* ``\$arr``[``\$i``];``        ``}` `        ``// update max_so_far, if needed``        ``if` `(``\$max_so_far` `< ``\$max_ending_here``)``            ``\$max_so_far` `= ``\$max_ending_here``;``    ``}` `    ``if``(``\$flag``==0 && ``\$max_so_far``==0) ``return` `0;``    ``return` `\$max_so_far``;``}` `// Driver Program to test above function``    ``\$arr` `= ``array``(1, -2, -3, 0, 7, -8, -2);``    ``\$n` `= 7;``    ``echo``(``"Maximum Sub array product is "``);``    ``echo` `(maxSubarrayProduct(``\$arr``, ``\$n``));` `// This code is contributed by nitin mittal``?>`

## Javascript

 ``

Output

`Maximum Sub array product is 112`

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

Efficient Approach: To solve the problem follow the below idea:

The above solution assumes there is always a positive outcome for the given array which does not work for cases where the array contains only non-positive elements like {0, 0, -20, 0}, {0, 0, 0}.. etc. The modified solution is also similar to the Largest Sum Contiguous Subarray problem which uses Kadane’s algorithm

Follow the below steps to solve the problem:

• Here we use 3 variables called max_so_far, max_ending_here & min_ending_here
• For every index, the maximum number ending at that index will be the maximum(arr[i], max_ending_here * arr[i], min_ending_here[i]*arr[i])
• Similarly, the minimum number ending here will be the minimum of these 3
• Thus we get the final value for the maximum product subarray

Below is the implementation of the above approach:

## C++

 `// C++ program to find Maximum Product Subarray``#include ``using` `namespace` `std;` `/* Returns the product``of max product subarray. */``int` `maxSubarrayProduct(``int` `arr[], ``int` `n)``{``    ``// max positive product``    ``// ending at the current position``    ``int` `max_ending_here = arr;` `    ``// min negative product ending``    ``// at the current position``    ``int` `min_ending_here = arr;` `    ``// Initialize overall max product``    ``int` `max_so_far = arr;``    ``/* Traverse through the array.``    ``the maximum product subarray ending at an index``    ``will be the maximum of the element itself,``    ``the product of element and max product ending previously``    ``and the min product ending previously. */``    ``for` `(``int` `i = 1; i < n; i++) {``        ``int` `temp = max({ arr[i], arr[i] * max_ending_here,``                         ``arr[i] * min_ending_here });``        ``min_ending_here``            ``= min({ arr[i], arr[i] * max_ending_here,``                    ``arr[i] * min_ending_here });``        ``max_ending_here = temp;``        ``max_so_far = max(max_so_far, max_ending_here);``    ``}``    ``return` `max_so_far;``}` `// Driver code``int` `main()``{``    ``int` `arr[] = { 1, -2, -3, 0, 7, -8, -2 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);``    ``cout << ``"Maximum Sub array product is "``         ``<< maxSubarrayProduct(arr, n);``    ``return` `0;``}` `// This code is contributed by Aditya Kumar (adityakumar129)`

## C

 `// C program to find Maximum Product Subarray``#include ` `// Find maximum between two numbers.``int` `max(``int` `num1, ``int` `num2)``{``    ``return` `(num1 > num2) ? num1 : num2;``}` `// Find minimum between two numbers.``int` `min(``int` `num1, ``int` `num2)``{``    ``return` `(num1 > num2) ? num2 : num1;``}` `/* Returns the product of max product subarray. */``int` `maxSubarrayProduct(``int` `arr[], ``int` `n)``{``    ``// max positive product``    ``// ending at the current position``    ``int` `max_ending_here = arr;` `    ``// min negative product ending``    ``// at the current position``    ``int` `min_ending_here = arr;` `    ``// Initialize overall max product``    ``int` `max_so_far = arr;``    ``/* Traverse through the array.``    ``the maximum product subarray ending at an index``    ``will be the maximum of the element itself,``    ``the product of element and max product ending previously``    ``and the min product ending previously. */``    ``for` `(``int` `i = 1; i < n; i++) {``        ``int` `temp``            ``= max(max(arr[i], arr[i] * max_ending_here),``                  ``arr[i] * min_ending_here);``        ``min_ending_here``            ``= min(min(arr[i], arr[i] * max_ending_here),``                  ``arr[i] * min_ending_here);``        ``max_ending_here = temp;``        ``max_so_far = max(max_so_far, max_ending_here);``    ``}``    ``return` `max_so_far;``}` `// Driver code``int` `main()``{``    ``int` `arr[] = { 1, -2, -3, 0, 7, -8, -2 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);``    ``printf``(``"Maximum Sub array product is %d"``,``           ``maxSubarrayProduct(arr, n));``    ``return` `0;``}` `// This code is contributed by Aditya Kumar (adityakumar129)`

## Java

 `/*package whatever //do not write package name here */``import` `java.io.*;` `class` `GFG {``    ``// Java program to find Maximum Product Subarray` `    ``// Returns the product``    ``// of max product subarray.``    ``static` `int` `maxSubarrayProduct(``int` `arr[], ``int` `n)``    ``{` `        ``// max positive product``        ``// ending at the current position``        ``int` `max_ending_here = arr[``0``];` `        ``// min negative product ending``        ``// at the current position``        ``int` `min_ending_here = arr[``0``];` `        ``// Initialize overall max product``        ``int` `max_so_far = arr[``0``];` `        ``// /* Traverse through the array.``        ``// the maximum product subarray ending at an index``        ``// will be the maximum of the element itself,``        ``// the product of element and max product ending``        ``// previously and the min product ending previously.``        ``// */``        ``for` `(``int` `i = ``1``; i < n; i++) {``            ``int` `temp = Math.max(``                ``Math.max(arr[i], arr[i] * max_ending_here),``                ``arr[i] * min_ending_here);``            ``min_ending_here = Math.min(``                ``Math.min(arr[i], arr[i] * max_ending_here),``                ``arr[i] * min_ending_here);``            ``max_ending_here = temp;``            ``max_so_far``                ``= Math.max(max_so_far, max_ending_here);``        ``}` `        ``return` `max_so_far;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String args[])``    ``{``        ``int``[] arr = { ``1``, -``2``, -``3``, ``0``, ``7``, -``8``, -``2` `};``        ``int` `n = arr.length;``        ``System.out.printf(``"Maximum Sub array product is %d"``,``                          ``maxSubarrayProduct(arr, n));``    ``}``}` `// This code is contributed by shinjanpatra`

## Python3

 `# Python3 program to find Maximum Product Subarray` `#  Returns the product``# of max product subarray.`  `def` `maxSubarrayProduct(arr, n):` `    ``# max positive product``    ``# ending at the current position``    ``max_ending_here ``=` `arr[``0``]` `    ``# min negative product ending``    ``# at the current position``    ``min_ending_here ``=` `arr[``0``]` `    ``# Initialize overall max product``    ``max_so_far ``=` `arr[``0``]` `    ``# /* Traverse through the array.``    ``# the maximum product subarray ending at an index``    ``# will be the maximum of the element itself,``    ``# the product of element and max product ending previously``    ``# and the min product ending previously. */``    ``for` `i ``in` `range``(``1``, n):``        ``temp ``=` `max``(``max``(arr[i], arr[i] ``*` `max_ending_here),``                   ``arr[i] ``*` `min_ending_here)``        ``min_ending_here ``=` `min``(``            ``min``(arr[i], arr[i] ``*` `max_ending_here), arr[i] ``*` `min_ending_here)``        ``max_ending_here ``=` `temp``        ``max_so_far ``=` `max``(max_so_far, max_ending_here)` `    ``return` `max_so_far`  `# Driver code``arr ``=` `[``1``, ``-``2``, ``-``3``, ``0``, ``7``, ``-``8``, ``-``2``]``n ``=` `len``(arr)``print``(f``"Maximum Sub array product is {maxSubarrayProduct(arr, n)}"``)` `# This code is contributed by shinjanpatra`

## C#

 `// C# program to find maximum product subarray``using` `System;` `class` `GFG {` `    ``/* Returns the product of max product subarray.``    ``Assumes that the given array always has a subarray``    ``with product more than 1 */``    ``static` `int` `maxSubarrayProduct(``int``[] arr)``    ``{``        ``// max positive product``        ``// ending at the current position``        ``int` `max_ending_here = arr;` `        ``// min negative product ending``        ``// at the current position``        ``int` `min_ending_here = arr;` `        ``// Initialize overall max product``        ``int` `max_so_far = arr;``        ``/* Traverse through the array.``        ``the maximum product subarray ending at an index``        ``will be the maximum of the element itself,``        ``the product of element and max product ending``        ``previously and the min product ending previously. */``        ``for` `(``int` `i = 1; i < arr.Length; i++) {``            ``int` `temp = Math.Max(``                ``Math.Max(arr[i], arr[i] * max_ending_here),``                ``arr[i] * min_ending_here);``            ``min_ending_here = Math.Min(``                ``Math.Min(arr[i], arr[i] * max_ending_here),``                ``arr[i] * min_ending_here);``            ``max_ending_here = temp;``            ``max_so_far``                ``= Math.Max(max_so_far, max_ending_here);``        ``}``        ``return` `max_so_far;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main()``    ``{` `        ``int``[] arr = { 1, -2, -3, 0, 7, -8, -2 };` `        ``Console.WriteLine(``"Maximum Sub array product is "``                          ``+ maxSubarrayProduct(arr));``    ``}``}` `// This code is contributed by CodeWithMini`

## Javascript

 ``

Output

`Maximum Sub array product is 112`

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