Maximum Product Subarray

Difficulty Level : Hard
Last Updated : 08 Apr, 2021

Given an array that contains both positive and negative integers, find the product of the maximum product subarray. Expected Time complexity is O(n) and only O(1) extra space can be used.

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}

Input: arr[] = {-2, -40, 0, -2, -3}
Output:   80  // The subarray is {-2, -40}

Naive Solution:

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

Below is the implementation of the above approach.

C++

// C++ program to find Maximum Product Subarray
#include <bits/stdc++.h>
using namespace std;
 
/* Returns the product of max product subarray.*/
int maxSubarrayProduct(int arr[], int n)
{
    // Initializing result
    int result = arr[0];
 
    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[0]);
    cout << "Maximum Sub array product is "
         << maxSubarrayProduct(arr, n);
    return 0;
}
 
// This code is contributed by yashbeersingh42

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 yashbeersingh42

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[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 };
     
    Console.Write("Maximum Sub array product is " +
                  maxSubarrayProduct(arr));
}
}
 
// This code is contributed by shivanisinghss2110

Javascript

<script>
 
// Javascript program to find Maximum Product Subarray
 
/* Returns the product of max product subarray.*/
function maxSubarrayProduct(arr, n)
{
    // Initializing result
    let result = arr[0];
 
    for (let i = 0; i < n; i++)
    {
        let mul = arr[i];
        // traversing in current subarray
        for (let 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
 
    let arr = [ 1, -2, -3, 0, 7, -8, -2 ];
    let n = arr.length;
    document.write("Maximum Sub array product is "
        + maxSubarrayProduct(arr, n));
     
 
// This code is contributed by Mayank Tyagi
 
</script>

Output:

Maximum Sub array product is 112

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

Efficient Solution:

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 Largest Sum Contiguous Subarray problem. The only thing to note here is, maximum product can also be obtained by 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 multiplication of, minimum product ending with -6 and -2.

C++

// C++ program to find Maximum Product Subarray
#include <bits/stdc++.h>
using namespace std;
 
/* 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 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;
    return max_so_far;
}
 
// Driver code
int main()
{
    int arr[] = { 1, -2, -3, 0, 7, -8, -2 };
    int n = sizeof(arr) / sizeof(arr[0]);
    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 <stdio.h>
 
// 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[0]);
    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 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(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*/

Python

# 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

<?php
// php program to find Maximum Product
// Subarray
 
// Utility functions to get minimum of
// two integers
function minn ($x, $y)
{
    return $x < $y? $x : $y;
}
 
// Utility functions to get maximum of
// two integers
function maxx ($x, $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 */
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 = sizeof($arr) / sizeof($arr[0]);
    echo("Maximum Sub array product is ");
    echo (maxSubarrayProduct($arr, $n));
 
// This code is contributed by nitin mittal
?>

Javascript

<script>
 
// JavaScript 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 */
function maxSubarrayProduct(arr, n)
{
    // max positive product
    // ending at the current position
    let max_ending_here = 1;
 
    // min negative product ending
    // at the current position
    let min_ending_here = 1;
 
    // Initialize overall max product
    let max_so_far = 0;
    let 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 (let 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
                = Math.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 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 {
            let temp = max_ending_here;
            max_ending_here
                = Math.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
     
    let arr = [ 1, -2, -3, 0, 7, -8, -2 ];
    let n = arr.length;
    document.write("Maximum Sub array product is " +
                    maxSubarrayProduct(arr,n));
     
</script>

Output

Maximum Sub array product is 112

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

This article is compiled by Dheeraj Jain and reviewed by GeeksforGeeks team. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes

Related Articles

C++

Java

Python3

C#

Javascript

C++

C

Java

Python

C#

PHP

Javascript