Maximum Product Subarray in DSA Go - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the goal of the Maximum Product Subarray problem?

To find the contiguous subarray within an array that has the largest product of its elements.

intermediate

Why do we track both maximum and minimum products at each step in the Maximum Product Subarray problem?

Because a negative number can turn a minimum product into a maximum product when multiplied, so tracking both helps handle negative values correctly.

beginner

In the Maximum Product Subarray problem, what happens when the current number is zero?

The product resets because zero multiplied by anything is zero, so we start fresh from the next element.

beginner

What is the time complexity of the standard solution for the Maximum Product Subarray problem?

O(n), where n is the number of elements in the array, because we scan the array once.

intermediate

Explain the role of dynamic programming in solving the Maximum Product Subarray problem.

Dynamic programming helps by storing the maximum and minimum products up to the current position, allowing efficient calculation of the maximum product subarray without recomputing products repeatedly.

What do you need to track at each step to solve the Maximum Product Subarray problem?

A Maximum and minimum product ending at current index

B Only maximum product ending at current index

C Sum of all elements so far

D Number of positive elements

Tracking both maximum and minimum products is necessary because a negative number can flip the minimum product to maximum.

If the current number is negative, what should you do with the maximum and minimum products?

A Swap maximum and minimum products before multiplying

B Ignore the minimum product

C Reset both to zero

D Only update maximum product

Multiplying by a negative number flips signs, so swapping helps keep track of correct max and min products.

What is the initial value of maximum and minimum products before starting the iteration?

A Negative infinity

B Zero

C First element of the array

D One

We start with the first element as both max and min product because the subarray must include at least one element.

What should you do when you encounter zero in the array?

A eno ot stcudorp nim dna xam teseR

B Reset max and min products to one

C Ignore zero and continue

D Stop processing the array

Zero resets the product, so max and min products are reset to one to start fresh from next elements.

What is the overall time complexity of the Maximum Product Subarray solution?

A O(1)

B O(n^2)

C O(log n)

D O(n)

The solution scans the array once, updating max and min products, so it runs in linear time.

Describe the approach to solve the Maximum Product Subarray problem step-by-step.

Think about how negative numbers affect product and why tracking both max and min is important.

Explain why tracking only the maximum product is not enough in the Maximum Product Subarray problem.

Consider what happens when multiplying by a negative number.

Practice

1. What does the "Maximum Product Subarray" problem ask you to find in an array of integers?

easy

A. The longest subarray with positive numbers

B. The contiguous subarray with the largest sum of its elements

C. The maximum single element in the array

D. The contiguous subarray with the largest product of its elements

Solution

1. Step 1: Understand the problem statement

   The problem asks for a contiguous part of the array where the product of all elements is the highest possible.

2. Step 2: Differentiate from similar problems

   Unlike maximum sum subarray, here we multiply elements, so negative numbers and zeros affect the product differently.

3. Final Answer:

   The contiguous subarray with the largest product of its elements -> Option D

4. Quick Check:

   Maximum product subarray = contiguous subarray with max product [OK]

Hint: Look for contiguous elements with max multiplication [OK]

Common Mistakes:

• Confusing product with sum
• Ignoring negative numbers impact
• Thinking about non-contiguous elements

2. Which of the following Go code snippets correctly initializes variables to track the maximum product subarray?

easy

A. maxProd, minProd, result := 1, 1, 1

B. maxProd, minProd, result := 0, 0, 0

C. maxProd, minProd, result := nums[0], nums[0], nums[0]

D. maxProd, minProd, result := -1, -1, -1

Solution

1. Step 1: Understand initialization for max product subarray

   We start with the first element as initial max, min, and result to handle negative and positive values correctly.

2. Step 2: Check each option's initialization

   maxProd, minProd, result := nums[0], nums[0], nums[0] uses nums[0] which is correct; others use fixed values that may not match array's first element.

3. Final Answer:

   maxProd, minProd, result := nums[0], nums[0], nums[0] -> Option C

4. Quick Check:

   Initialize with first element for correct tracking [OK]

Hint: Initialize with first element, not zero or one [OK]

Common Mistakes:

• Initializing with zero causes wrong results if nums[0] is negative
• Using 1 ignores negative or zero first elements
• Not initializing minProd separately

3. What is the output of the following Go code for the input array nums := []int{2, 3, -2, 4}?

func maxProduct(nums []int) int {
    maxProd, minProd, result := nums[0], nums[0], nums[0]
    for i := 1; i < len(nums); i++ {
        if nums[i] < 0 {
            maxProd, minProd = minProd, maxProd
        }
        maxProd = max(nums[i], maxProd*nums[i])
        minProd = min(nums[i], minProd*nums[i])
        if maxProd > result {
            result = maxProd
        }
    }
    return result
}

func max(a, b int) int {
    if a > b {
        return a
    }
    return b
}

func min(a, b int) int {
    if a < b {
        return a
    }
    return b
}

medium

A. 6

B. 4

C. -2

D. 8

Solution

1. Step 1: Trace the loop and update maxProd, minProd, and result

   Start with maxProd=2, minProd=2, result=2 - i=1 (3): nums[i]=3 > 0, maxProd=max(3,2*3)=6, minProd=min(3,2*3)=3, result=6 - i=2 (-2): nums[i]<0, swap maxProd and minProd (maxProd=3, minProd=6), maxProd=max(-2,3*(-2))=-2, minProd=min(-2,6*(-2))=-12, result=6 - i=3 (4): nums[i]>0, maxProd=max(4,-2*4)=4, minProd=min(4,-12*4)=-48, result=6

2. Step 2: Determine final result

   The maximum product found is 6 from subarray [2,3].

3. Final Answer:

   6 -> Option A

4. Quick Check:

   Max product subarray = 6 [OK]

Hint: Swap max and min when negative number found [OK]

Common Mistakes:

• Not swapping max and min on negative number
• Confusing max and min updates
• Ignoring update of result

4. Identify the bug in this Go code snippet for maximum product subarray:

func maxProduct(nums []int) int {
    maxProd, minProd, result := nums[0], nums[0], nums[0]
    for i := 1; i < len(nums); i++ {
        if nums[i] > 0 {
            maxProd = max(maxProd*nums[i], nums[i])
            minProd = min(minProd*nums[i], nums[i])
        } else {
            maxProd = max(minProd*nums[i], nums[i])
            minProd = min(maxProd*nums[i], nums[i])
        }
        if maxProd > result {
            result = maxProd
        }
    }
    return result
}

medium

A. Swapping maxProd and minProd is missing when nums[i] is negative

B. Initialization of maxProd, minProd, result is incorrect

C. Loop should start from i = 0 instead of 1

D. max and min functions are not defined

Solution

1. Step 1: Analyze handling of negative numbers

   When nums[i] is negative, maxProd and minProd should be swapped before updating because multiplying by negative flips max and min.

2. Step 2: Check the code's else block

   The code updates maxProd and minProd without swapping, causing incorrect results for negative numbers.

3. Final Answer:

   Swapping maxProd and minProd is missing when nums[i] is negative -> Option A

4. Quick Check:

   Swap max and min on negative input [OK]

Hint: Always swap max and min before multiplying negative number [OK]

Common Mistakes:

• Forgetting to swap maxProd and minProd
• Updating maxProd before minProd causing wrong minProd
• Starting loop at wrong index

5. Given the array nums := []int{-1, -3, -10, 0, 60}, what is the maximum product subarray and its product?

hard

A. Subarray [-1, -3, -10] with product -30

B. Subarray [60] with product 60

C. Subarray [-3, -10, 0, 60] with product 0

D. Subarray [-10, 0, 60] with product 0

Solution

1. Step 1: Evaluate products of possible subarrays

   Check subarrays: - [-1, -3, -10]: product = -1 * -3 * -10 = -30 - [60]: product = 60 - [-3, -10, 0, 60]: product = 0 (due to zero) - [-10, 0, 60]: product = 0 (due to zero)

2. Step 2: Identify maximum product

   The highest product is 60 from subarray [60].

3. Final Answer:

   Subarray [60] with product 60 -> Option B

4. Quick Check:

   Max product = 60 from single element [OK]

Hint: Check single elements when zeros reset product [OK]

Common Mistakes:

• Multiplying negative numbers without counting sign flips
• Ignoring zero resets product
• Assuming longer subarray always has max product