Java Program for Maximum Product Subarray - GeeksforGeeks

21 Dec, 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.
Java
// Java program to find maximum product subarrayimport 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
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. 
Java
// Java program to find maximum product subarrayimport 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*/
Maximum Sub array product is 112
Time Complexity: O(n) Auxiliary Space: O(1)
Please refer complete article on Maximum Product Subarray for more details!
Amazon
Microsoft
Morgan Stanley
Myntra
Myntra-Question
Arrays
Java
Java Programs
Morgan Stanley
Amazon
Microsoft
Myntra
Arrays
Java
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Program to find sum of elements in a given array
Trapping Rain Water
Reversal algorithm for array rotation
Move all negative numbers to beginning and positive to end with constant extra space
Window Sliding Technique
Split() String method in Java with examples
For-each loop in Java
Reverse a string in Java
HashMap in Java with Examples
Interfaces in Java