Maximum Product Subarray

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

Examples:

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

Input: arr[] = {-1, -3, -10, 0, 60}
Output:   60
Explanation: The subarray is {60}

Maximum Product Subarray by Traverse Over Every Contiguous Subarray:

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 <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 Aditya Kumar (adityakumar129)

C

// C program to find Maximum Product Subarray
#include <stdio.h>

// 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[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]);
    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[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)

Maximum Product Subarray using Kadane’s Algorithm

The idea is to use Kadane’s algorithm and maintain 3 variables max_so_far, max_ending_here & min_ending_here. Iterate the indices 0 to N-1 and update the variables such that:

• max_ending_here = maximum(arr[i], max_ending_here * arr[i], min_ending_here[i]*arr[i])
• min_ending_here = maximum(arr[i], max_ending_here * arr[i], min_ending_here[i]*arr[i])
• update the max_so_far with the maximum value for each index.

return max_so_far as the result.

Follow the below steps to solve the problem:

• Use 3 variables, 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 <bits/stdc++.h>
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[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 = 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[0]);
    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 <stdio.h>

// 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[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
            = 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[0]);
    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[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 < 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

<script>

// JavaScript program to find Maximum Product Subarray

/* Returns the product
of max product subarray. */
function maxSubarrayProduct(arr, n)
{

    // max positive product
    // ending at the current position
    let max_ending_here = arr[0];

    // min negative product ending
    // at the current position
    let min_ending_here = arr[0];

    // Initialize overall max product
    let 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 (let i = 1; i < n; i++)
    {
        let 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
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 shinjanpatra

</script>

Output

Maximum Sub array product is 112

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

Maximum Product Subarray using Traversal From Starting and End of an Array:

We will follow a simple approach that is to traverse and multiply elements and if our value is greater than the previously stored value then store this value in place of the previously stored value. If we encounter “0” then make products of all elements till now equal to 1 because from the next element, we will start a new subarray.

But what can be the problem with that?

Problem will occur when our array will contain odd no. of negative elements. In that case, we have to reject anyone negative element so that we can even no. of negative elements and their product can be positive. Now since we are considering subarray so we can’t simply reject any one negative element. We have to either reject the first negative element or the last negative element.

But if we will traverse from starting then only the last negative element can be rejected and if we traverse from the last then the first negative element can be rejected. So we will traverse from both the end and from both the traversal we will take answer from that traversal only which will give maximum product subarray.

So actually we will reject that negative element whose rejection will give us the maximum product’s subarray.

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. */
long long int maxSubarrayProduct(int arr[], int n)
{
   long long ans=INT_MIN;
   long long product=1;

   for(int i=0;i<n;i++){
       product*=arr[i];
       ans=max(ans,product);
       if(arr[i]==0){product=1;}
   }

   product=1;

   for(int i=n-1;i>=0;i--){
       product*=arr[i];
       ans=max(ans,product);
       if(arr[i]==0){product=1;}
   }
   return ans;
}

// 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;
}

Java

// Java program to find Maximum Product Subarray
import java.util.*;

public class Main {
    /* Returns the product of max product subarray. */
    public static long maxSubarrayProduct(int[] arr, int n)
    {
        long ans = Integer.MIN_VALUE;
        long product = 1;
        // Traverse the array from left to right
        for (int i = 0; i < n; i++) {
            product *= arr[i];
            ans = Math.max(ans, product);
            if (arr[i] == 0) {
                product = 1;
            }
        }

        product = 1;

        // Traverse the array from right to left
        for (int i = n - 1; i >= 0; i--) {
            product *= arr[i];
            ans = Math.max(ans, product);
            if (arr[i] == 0) {
                product = 1;
            }
        }
        return ans;
    }

    // Driver code
    public static void main(String[] args)
    {
        int[] arr = { 1, -2, -3, 0, 7, -8, -2 };
        int n = arr.length;
        System.out.println("Maximum Subarray product is "
                           + maxSubarrayProduct(arr, n));
    }
}

Python3

# Python program to find Maximum Product Subarray

import sys

# Returns the product of max product subarray.
def maxSubarrayProduct(arr, n):
    ans = -sys.maxsize - 1  # Initialize the answer to the minimum possible value
    product = 1

    for i in range(n):
        product *= arr[i]
        ans = max(ans, product)  # Update the answer with the maximum of the current answer and product
        if arr[i] == 0:
            product = 1  # Reset the product to 1 if the current element is 0

    product = 1

    for i in range(n - 1, -1, -1):
        product *= arr[i]
        ans = max(ans, product)
        if arr[i] == 0:
            product = 1

    return ans

# Driver code
arr = [1, -2, -3, 0, 7, -8, -2]
n = len(arr)
print("Maximum Subarray product is", maxSubarrayProduct(arr, n))

C#

using System;

public class MainClass {
    // Returns the product of max product subarray.
    public static int MaxSubarrayProduct(int[] arr, int n)
    {
        int ans
            = int.MinValue; // Initialize the answer to the
                            // minimum possible value
        int product = 1;

        for (int i = 0; i < n; i++) {
            product *= arr[i];
            ans = Math.Max(
                ans, product); // Update the answer with the
                               // maximum of the current
                               // answer and product
            if (arr[i] == 0) {
                product = 1; // Reset the product to 1 if
                             // the current element is 0
            }
        }

        product = 1;

        for (int i = n - 1; i >= 0; i--) {
            product *= arr[i];
            ans = Math.Max(ans, product);
            if (arr[i] == 0) {
                product = 1;
            }
        }

        return ans;
    }

    // Driver code
    public static void Main()
    {
        int[] arr = { 1, -2, -3, 0, 7, -8, -2 };
        int n = arr.Length;
        Console.WriteLine("Maximum Subarray product is "
                          + MaxSubarrayProduct(arr, n));
    }
}

Javascript

// JavaScript program to find Maximum Product Subarray

// Function to find the maximum product subarray
function maxSubarrayProduct(arr, n) {
  let ans = -Infinity;
  let product = 1;

  for (let i = 0; i < n; i++) {
    product *= arr[i];
    ans = Math.max(ans, product);
    if (arr[i] === 0) {
      product = 1;
    }
  }

  product = 1;

  for (let i = n - 1; i >= 0; i--) {
    product *= arr[i];
    ans = Math.max(ans, product);
    if (arr[i] === 0) {
      product = 1;
    }
  }

  return ans;
}

// Driver code
const arr = [1, -2, -3, 0, 7, -8, -2];
const n = arr.length;
console.log(`Maximum Subarray product is ${maxSubarrayProduct(arr, n)}`);

//This code is written by Sundaram

Output

Maximum Sub array product is 112

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