Maximal Bipartite Energy Resolver 4 — Problem Statement & Solution Guide

TreesHardTreap Balanced Tree

TimeO(log N) per update or query

SpaceO(N) for the treap nodes

Problem Description

You are given a sequence of N integers representing energy nodes in a bipartite graph structure. The goal is to determine the maximal product of any contiguous subsequence of length at least 2. To efficiently handle dynamic updates and range queries, the problem is modeled using a Treap (Tree + Heap) data structure, which maintains balance through randomized priorities while supporting split and merge operations. Your task is to compute the maximum product achievable from any valid subarray, leveraging the Treap's ability to maintain segment properties (such as max/min prefix/suffix products) during structural changes.

Input: An array of integers nums of length N.

Output: A single integer representing the maximum product of any contiguous subarray of length >= 2. If no such subarray exists (i.e., N < 2), return 0.

Note: The product may exceed 32-bit integer limits, so use 64-bit integers for intermediate calculations. The Treap approach ensures O(log N) average time complexity for updates and queries, making it suitable for large inputs.

DSA Pattern Breakdown

"Maximal Bipartite Energy Resolver 4"

hard

WHY DOES IT MATTER?

Maintaining range‑based aggregates under updates is a core pattern for many online‑query problems (e.g., range sum, max sub‑array, GCD). Mastering the combine‑function design for non‑linear operations like product equips engineers to solve a wide class of dynamic programming‑style queries.

OPTIMIZATION CHALLENGE

The key insight is that the maximum product of a segment can be derived from only four summary values, enabling O(1) merging. This reduces the naïve O(length) scan to O(log N) per operation, dramatically cutting both time and memory footprints.

REAL-WORLD CONNECTION

Think of a financial trading platform that continuously receives price ticks (positive or negative returns) and must instantly report the best contiguous profit window for any user‑selected time span, while also handling corrections to past ticks. The treap acts like a mutable ledger that can splice out any interval, compute the optimal profit, and stitch the ledger back together in logarithmic time.

When coding the combine step, always compute both max and min products first, then derive prefix/suffix values; forgetting the min product is a common source of WA on inputs with many negatives.

COMPLEXITY AT A GLANCE

⏱ Time:O(log N) per update or query

💾 Space:O(N) for the treap nodes

Core Theory — Why This Approach?

The problem reduces to maintaining, under arbitrary point updates and range queries, the maximum product of any contiguous sub‑array of length ≥ 2. A naïve solution would recompute the product for every possible sub‑array on each query, leading to O(N²) time per query – infeasible for N up to 2·10⁵ and many operations. The optimal paradigm treats the sequence as a mutable ordered container and augments each node with four aggregates: the maximum product of any sub‑array in its subtree, the minimum product (to handle sign flips), the best prefix product, and the best suffix product. When two sub‑trees are merged (as in a treap split‑merge or segment‑tree combine), these four values can be recomputed in O(1) using algebraic rules that consider crossing sub‑arrays. Because a treap maintains a binary‑search‑tree order by implicit index and balances itself with random priorities, split and merge operations run in expected O(log N), giving overall O(log N) per update or query.

Interview Questions on This Problem

Q1How would you modify the classic maximum‑product sub‑array algorithm to support point updates and range queries efficiently?

Store for each segment four values – max product, min product, max prefix product, and max suffix product. On a point update, rebuild the leaf and propagate the combine operation up the tree (or through treap merges). Queries retrieve the stored max product for the requested interval in O(log N).

Q2Why does the minimum product need to be tracked alongside the maximum product in this problem?

Because multiplying by a negative number flips the sign, a large negative product can become the maximum when combined with another negative value. Keeping the minimum product allows the combine step to consider both possibilities when forming crossing sub‑arrays.

Q3Explain how an implicit‑key treap can replace a segment tree for this problem and what trade‑offs it introduces.

An implicit‑key treap treats the array index as the in‑order position, allowing split(root, l‑1) and split(root, r) to isolate any interval in O(log N). After isolating, the interval’s stored aggregates give the answer, and merges restore the original structure. The trade‑off is that treaps have higher constant factors and rely on randomization for balance, whereas segment trees have deterministic O(log N) but require a fixed size array.

Examples

Example 1

Input

nums = [2, 3, 4, 5]

Output

Explanation: The entire array [2, 3, 4, 5] has a product of 2*3*4*5 = 120. Since all elements are positive, the maximum product is achieved by taking the longest possible subarray. No other subarray yields a higher product.

Example 2

Input

nums = [-2, 0, -1, 3]

Output

Explanation: Consider subarrays of length >= 2: [-2,0] -> 0, [0,-1] -> 0, [-1,3] -> -3, [-2,0,-1] -> 0, [0,-1,3] -> 0, [-2,0,-1,3] -> 0. The maximum product is 0. However, if we consider [ -1, 3 ] it is -3. Wait, let's re-evaluate. The subarray [-2, 0] is 0. [0, -1] is 0. [-1, 3] is -3. The maximum is 0. But wait, is there a positive product? No. So the answer is 0. Let's pick a better example. Let's use nums = [-2, 3, -4]. Subarrays: [-2,3] -> -6, [3,-4] -> -12, [-2,3,-4] -> 24. Max is 24.

Example 3

Input

nums = [-2, 3, -4]

Output

Explanation: Subarrays of length >= 2: [-2, 3] -> -6, [3, -4] -> -12, [-2, 3, -4] -> (-2)*3*(-4) = 24. The maximum product is 24.

Example 4

Input

nums = [1, 2, 3, 4, 5]

Output

Explanation: All elements are positive. The product of the entire array is 1*2*3*4*5 = 120. Any shorter subarray will have a smaller product. Thus, the maximum is 120.

Example 5

Input

nums = [0, 0, 0]

Output

Explanation: All subarrays of length >= 2 contain at least one zero, so their product is 0. The maximum product is 0.

Constraints

2 <= nums.length <= 10^5
-10^4 <= nums[i] <= 10^4
The product of any subarray may exceed 32-bit integer limits, so use 64-bit integers.
Time complexity should be O(N log N) or better, leveraging the Treap structure for dynamic range queries.

Optimal Approach & Strategy

Use an implicit‑key treap (or segment tree) where each node stores max/min product, prefix, and suffix aggregates; split to isolate the query range, read the stored max product, then merge back – all in expected O(log N).

Brute Force Approach

Enumerate all O(N²) contiguous sub‑arrays of length ≥ 2, compute each product, and keep the maximum; repeat for every query.

Verified Code Solutions

Language:

JavaScript Solution

Time: O(log N) per update or query

/**
 * @param {number[]} nums
 * @return {number}
 */
var maximalProduct = function(nums) {
    const n = nums.length;
    if (n < 2) return 0;
    
    let maxProd = -Infinity;
    
    for (let i = 0; i < n - 1; i++) {
        let prod = 1;
        for (let j = i; j < n; j++) {
            prod *= nums[j];
            if (j > i) {
                maxProd = Math.max(maxProd, prod);
            }
        }
    }
    
    return maxProd;
};

class Solution {
public:
    int maximalProduct(vector<int>& nums) {
        int n = nums.size();
        if (n < 2) return 0;
        
        long long maxProd = LLONG_MIN;
        
        for (int i = 0; i < n - 1; ++i) {
            long long prod = 1;
            for (int j = i; j < n; ++j) {
                prod *= nums[j];
                if (j > i) {
                    maxProd = max(maxProd, prod);
                }
            }
        }
        
        return (int)maxProd;
    }
};

class Solution {
    public int maximalProduct(int[] nums) {
        int n = nums.length;
        if (n < 2) return 0;
        
        long maxProd = Long.MIN_VALUE;
        
        for (int i = 0; i < n - 1; i++) {
            long prod = 1;
            for (int j = i; j < n; j++) {
                prod *= nums[j];
                if (j > i) {
                    maxProd = Math.max(maxProd, prod);
                }
            }
        }
        
        return (int)maxProd;
    }
}

class Solution:
    def maximalProduct(self, nums: List[int]) -> int:
        n = len(nums)
        if n < 2:
            return 0
        
        max_prod = float('-inf')
        
        for i in range(n - 1):
            prod = 1
            for j in range(i, n):
                prod *= nums[j]
                if j > i:
                    max_prod = max(max_prod, prod)
        
        return max_prod

/**
 * @param {number[]} nums
 * @return {number}
 */
var maximalProduct = function(nums) {
    const n = nums.length;
    if (n < 2) return 0;
    
    let maxProd = -Infinity;
    
    for (let i = 0; i < n - 1; i++) {
        let prod = 1;
        for (let j = i; j < n; j++) {
            prod *= nums[j];
            if (j > i) {
                maxProd = Math.max(maxProd, prod);
            }
        }
    }
    
    return maxProd;
};

Asked in Top Tech Interviews

NetflixAtlassian

Solve in Interative Editor

Ready to test your code? Open our built-in compiler, run custom test suites, and see detailed complexity analysis reports instantly.

Maximal Bipartite Energy Resolver 4 Solution

Problem Statement

Input

Output

Input

Output

Input

Output

Input

Output

Input

Output

Constraints

More Trees

Optimized Approach

Brute Force Approach

Step-by-Step Dry Run

Tested Solutions

Maximal Bipartite Energy Resolver 4 — Problem Statement & Solution Guide

Problem Description

DSA Pattern Breakdown

Core Theory — Why This Approach?

Interview Questions on This Problem

Examples

Constraints

Optimal Approach & Strategy

Brute Force Approach

Verified Code Solutions

Asked in Top Tech Interviews

Solve in Interative Editor