Most Beautiful Item for Each Query - Practice Coding Problems

Most Beautiful Item for Each Query - Problem

Find the Most Beautiful Item Within Budget!

Imagine you're shopping at a luxury boutique where each item has both a price and a beauty rating. You have multiple shopping queries, each with a different budget limit.

Given:
• A 2D array items where items[i] = [price_i, beauty_i]
• An array queries where each queries[j] represents your maximum budget

Your task: For each query budget, find the maximum beauty value of any item you can afford (price ≤ budget). If no items are affordable, return 0.

Example: If items = [[1,2],[3,2],[2,4],[5,6],[3,5]] and queries = [1,2,3,4], then:
• Budget 1: Can afford item [1,2] → beauty = 2
• Budget 2: Can afford [1,2], [2,4] → max beauty = 4
• Budget 3: Can afford [1,2], [2,4], [3,2], [3,5] → max beauty = 5
• Budget 4: Same as budget 3 → max beauty = 5

Input & Output

example_1.py — Basic Case

$ Input: items = [[1,2],[3,2],[2,4],[5,6],[3,5]], queries = [1,2,3,4]

› Output: [2,4,5,5]

💡 Note: Query 1: Only [1,2] is affordable → beauty = 2. Query 2: [1,2] and [2,4] are affordable → max beauty = 4. Query 3: [1,2], [2,4], [3,2], [3,5] are affordable → max beauty = 5. Query 4: Same items as query 3 → max beauty = 5.

example_2.py — No Affordable Items

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

› Output: [4]

💡 Note: All items have price 1, so with budget 1, we can afford all of them. The maximum beauty among items with the same price is 4.

example_3.py — Budget Too Low

$ Input: items = [[10,1000]], queries = [5]

› Output: [0]

💡 Note: The only item costs 10, but our budget is 5, so we can't afford anything. Return 0.

Constraints

1 ≤ items.length ≤ 10⁵
items[i].length == 2
1 ≤ price_i, beauty_i ≤ 10⁹
1 ≤ queries.length ≤ 10⁵
1 ≤ queries[j] ≤ 10⁹
Large dataset optimization required

Visualization

Tap to expand

Understanding the Visualization

Organize by Price

Arrange all items on shelves sorted by price from lowest to highest

Create Beauty Guide

For each price point, note the maximum beauty available up to that price

Quick Customer Service

When a customer states their budget, use binary search to instantly find the best recommendation

Key Takeaway

🎯 Key Insight: By sorting items and precomputing maximum beauty prefixes, we transform an O(n×m) brute force solution into an efficient O((n+m) log n) solution using binary search!

Asked in

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

The optimal solution uses sorting + binary search approach. First, sort items by price and precompute maximum beauty prefixes. Then for each query, use binary search to find the rightmost affordable item and return its precomputed maximum beauty. Time complexity: O((n+m) log n).

Common Approaches

Approach	Time	Space	Notes
✓ Sorting + Binary Search (Optimal)	O(n log n + m log n)	O(n)	Sort items by price, precompute max beauty prefix, then binary search for each query
Brute Force (Check Every Item)	O(n × m)	O(1)	For each query, scan through all items to find the maximum beauty within budget

Sorting + Binary Search (Optimal) — Algorithm Steps

Sort items by price in ascending order
Create prefix array where each position stores max beauty up to that price
For each query, use binary search to find the rightmost item within budget
Return the precomputed max beauty for that position

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort & Precompute

Sort items by price and compute maximum beauty prefixes

Binary Search

For each query, binary search to find the rightmost affordable item

Instant Answer

Return the precomputed maximum beauty for that price range

Code -

solution.c — C

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

int compare(const void* a, const void* b) {
    int* itemA = *(int**)a;
    int* itemB = *(int**)b;
    return itemA[0] - itemB[0];
}

int* maximumBeauty(int** items, int itemsSize, int* itemsColSize, int* queries, int queriesSize, int* returnSize) {
    *returnSize = queriesSize;
    
    // Sort items by price
    qsort(items, itemsSize, sizeof(int*), compare);
    
    // Precompute maximum beauty up to each price point
    int maxBeauty = 0;
    for (int i = 0; i < itemsSize; i++) {
        if (items[i][1] > maxBeauty) {
            maxBeauty = items[i][1];
        }
        items[i][1] = maxBeauty;
    }
    
    int* result = (int*)malloc(queriesSize * sizeof(int));
    for (int i = 0; i < queriesSize; i++) {
        // Binary search for the rightmost item within budget
        int left = 0, right = itemsSize - 1;
        int maxBeautyInBudget = 0;
        
        while (left <= right) {
            int mid = (left + right) / 2;
            if (items[mid][0] <= queries[i]) {
                maxBeautyInBudget = items[mid][1];
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        
        result[i] = maxBeautyInBudget;
    }
    
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n log n + m log n)

O(n log n) for sorting items, O(m log n) for m binary searches

⚡ Linearithmic

Space Complexity

O(n)

Extra space for sorted items and prefix beauty array

⚡ Linearithmic Space

52.8K Views

Medium-High Frequency

~15 min Avg. Time

1.8K 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

Sorting + Binary Search (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler