Maximum Product Subarray

• Difficulty Level : Hard
• Last Updated : 11 Jan, 2022

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 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 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;         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       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 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 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);     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 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*/

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 = sizeof(\$arr) / sizeof(\$arr);     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 Solution:

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 Largest Sum Contiguous Subarray problem which uses Kadane’s algorithm. For ease of understanding we are not using any flag like the previous solution. Here we use 3 variable 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 maximum product subarray.

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 is code is contributed by kaustav