Maximum Sum Queries

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

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

✓ Brute Force (Check All Indices)

⏱️ Time: O(n × m) Space: O(1)

The most straightforward approach: for each query, iterate through all indices and check if both conditions are satisfied. Keep track of the maximum sum found.

Sorting + Monotonic Stack (Optimal)

⏱️ Time: O((n + m) log n) Space: O(n)

Sort all indices by nums1 values in descending order, then for each query, find valid candidates and use a monotonic stack to efficiently track the best nums2 values. This eliminates dominated points and reduces search space significantly.

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>
#include <string.h>

static int nums1[100000], nums2[100000];
static int queries[100000][2];
static int result[100000];

int parseArray(const char* str, int* arr) {
    int size = 0;
    char* copy = strdup(str);
    char* token = strtok(copy, ",");
    
    while (token != NULL) {
        arr[size++] = (int)strtol(token, NULL, 10);
        token = strtok(NULL, ",");
    }
    
    free(copy);
    return size;
}

int parseQueries(const char* str, int queries[][2]) {
    int count = 0;
    const char* p = str;
    
    while (*p) {
        if (*p == '[') {
            p++;
            int x = (int)strtol(p, (char**)&p, 10);
            if (*p == ',') {
                p++;
                int y = (int)strtol(p, (char**)&p, 10);
                queries[count][0] = x;
                queries[count][1] = y;
                count++;
                // Skip to the closing bracket
                while (*p && *p != ']') p++;
                if (*p == ']') p++;
            }
        } else {
            p++;
        }
    }
    
    return count;
}

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

int main() {
    char line1[10000], line2[10000], line3[10000];
    
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    fgets(line3, sizeof(line3), stdin);
    
    line1[strcspn(line1, "\n")] = 0;
    line2[strcspn(line2, "\n")] = 0;
    line3[strcspn(line3, "\n")] = 0;
    
    int nums1Size = parseArray(line1, nums1);
    int nums2Size = parseArray(line2, nums2);
    int queriesSize = parseQueries(line3, queries);
    
    int returnSize;
    int* res = maximumSumQueries(nums1, nums1Size, nums2, nums2Size, queries, queriesSize, &returnSize);
    
    if (returnSize == 1) {
        printf("[%d]\n", res[0]);
    } else {
        printf("[");
        for (int i = 0; i < returnSize; i++) {
            if (i > 0) printf(",");
            printf("%d", res[i]);
        }
        printf("]\n");
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

For each of m queries, we check all n indices

⚡ Linearithmic

Space Complexity

O(1)

Only using a few variables, no additional data structures

⚡ Linearithmic 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