Codestin Search App

Maximum Sum Queries - Problem

Array Binary Search Stack Binary Indexed Tree Segment Tree Sorting Monotonic Stack Hard

Maximum Sum Queries

You're given two arrays nums1 and nums2 of equal length, and a collection of queries. Each query asks: "What's the maximum sum of nums1[j] + nums2[j] where nums1[j] is at least x and nums2[j] is at least y?"

The Challenge: For each query [x, y], find an index j where both conditions are met: nums1[j] >= x AND nums2[j] >= y. Among all valid indices, return the one with the maximum sum nums1[j] + nums2[j].

If no such index exists, return -1 for that query.

Example: If nums1 = [4,3,1], nums2 = [2,4,9], and query is [4,1], only index 0 satisfies both conditions (4>=4 and 2>=1), so return 4+2=6.

Input & Output

example_1.py — Basic Case

$ Input: nums1 = [4,3,1], nums2 = [2,4,9], queries = [[4,1],[1,3],[2,5]]

› Output: [6,10,-1]

💡 Note: Query [4,1]: Only index 0 satisfies (4>=4 and 2>=1), sum = 4+2 = 6. Query [1,3]: Indices 1,2 satisfy conditions, max sum is 1+9 = 10 at index 2. Query [2,5]: No index satisfies both conditions, return -1.

example_2.py — All Valid

$ Input: nums1 = [3,2,5], nums2 = [2,3,4], queries = [[1,1]]

› Output: [9]

💡 Note: All indices satisfy nums1[j]>=1 and nums2[j]>=1. Index 2 gives maximum sum: 5+4=9.

example_3.py — No Valid Points

$ Input: nums1 = [1,2,3], nums2 = [4,3,2], queries = [[4,4]]

› Output: [-1]

💡 Note: No index satisfies both nums1[j]>=4 and nums2[j]>=4, so return -1.

Constraints

1 ≤ nums1.length, nums2.length ≤ 10⁵
1 ≤ nums1[i], nums2[i] ≤ 10⁹
1 ≤ queries.length ≤ 10⁵
queries[i].length == 2
1 ≤ xi, yi ≤ 10⁹

Visualization

Tap to expand

Understanding the Visualization

Plot Points

Each index becomes a point (nums1[i], nums2[i]) with value nums1[i] + nums2[i]

Sort by X-coordinate

Sort all points by nums1 values to handle one dimension efficiently

Eliminate Dominated Points

Use monotonic stack to keep only points that could be optimal for some query

Answer Queries

For each query rectangle, find the best point among candidates

Key Takeaway

🎯 Key Insight: By sorting one dimension and using a monotonic stack for the other, we eliminate all dominated points and can efficiently answer range maximum queries in 2D space.

Asked in

G Google 45 f Meta 38 a Amazon 32 ⊞ Microsoft 28

The optimal solution uses sorting and monotonic stack to efficiently handle 2D range queries. By sorting indices by one dimension and maintaining a stack of non-dominated points in the other dimension, we can answer each query in O(log n) time after preprocessing, achieving O((n + m) log n) overall complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Indices)	O(n × m)	O(1)	For each query, check every index to find the maximum sum
Sorting + Monotonic Stack (Optimal)	O((n + m) log n)	O(n)	Sort indices by one dimension, use monotonic stack to efficiently handle the other

Brute Force (Check All Indices) — Algorithm Steps

For each query [x, y]
Initialize maxSum to -1
Check every index j from 0 to n-1
If nums1[j] >= x AND nums2[j] >= y, update maxSum
Return maxSum for this query

Visualization

Tap to expand

Step-by-Step Walkthrough

Receive Query

Get query [x, y] requirements

Check All Indices

Iterate through each index checking both conditions

Track Maximum

Keep track of the best sum found so far

Return Result

Return maximum sum or -1 if no valid index found

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

int* maximumSumQueries(int* nums1, int nums1Size, int* nums2, int nums2Size, int** queries, int queriesSize, int* queriesColSize, int* returnSize) {
    int* result = (int*)malloc(queriesSize * sizeof(int));
    *returnSize = queriesSize;
    
    for (int i = 0; i < queriesSize; i++) {
        int x = queries[i][0], y = queries[i][1];
        int maxSum = -1;
        
        for (int j = 0; j < nums1Size; j++) {
            if (nums1[j] >= x && nums2[j] >= y) {
                int currentSum = nums1[j] + nums2[j];
                if (currentSum > maxSum) {
                    maxSum = currentSum;
                }
            }
        }
        
        result[i] = maxSum;
    }
    
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

For each of m queries, we check all n indices

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables, no additional data structures

✓ Linear Space

23.4K Views

Medium Frequency

~25 min Avg. Time

847 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Check All Indices) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler