Largest Values From Labels - Practice Coding Problems

Largest Values From Labels - Problem

Imagine you're a treasure hunter with a collection of valuable items, each marked with different labels indicating their categories. You want to maximize your treasure value, but there are two important constraints:

Limited bag space: You can only carry at most numWanted items
Category diversity: You can't take more than useLimit items from the same category (label)

Given two arrays:

values - the value of each item
labels - the category label of each item

Your goal is to select a subset of items that maximizes the total value while respecting both constraints.

Example: If you have items with values [5,4,3,2,1] and labels [1,1,2,2,3], and you want at most 3 items with at most 1 item per label, you'd pick the items with values 5, 3, and 1 (one from each label) for a total of 9.

Input & Output

example_1.py — Basic Selection

$ Input: values = [5,4,3,2,1], labels = [1,1,2,2,3], numWanted = 3, useLimit = 1

› Output: 9

💡 Note: We can select items with values 5 (label 1), 3 (label 2), and 1 (label 3). Each label appears at most once, and we selected exactly 3 items for a total of 9.

example_2.py — Multiple Items Per Label

$ Input: values = [5,4,3,2,1], labels = [1,3,3,3,2], numWanted = 3, useLimit = 2

› Output: 12

💡 Note: We can select items with values 5 (label 1), 4 (label 3), and 3 (label 3). Label 3 appears twice which is within the limit of 2, giving us a total of 12.

example_3.py — Limited by numWanted

$ Input: values = [9,8,8,7,6], labels = [0,0,0,1,1], numWanted = 2, useLimit = 3

› Output: 17

💡 Note: We can select items with values 9 and 8 (both label 0). Even though useLimit allows 3 items per label, numWanted limits us to 2 items total, giving us 9 + 8 = 17.

Constraints

1 ≤ values.length == labels.length ≤ 2 * 10⁴
0 ≤ values[i], labels[i] ≤ 2 * 10⁴
1 ≤ numWanted, useLimit ≤ values.length
All values and labels are non-negative integers

Visualization

Tap to expand

Understanding the Visualization

Sort Treasures by Value

Arrange all treasures from most valuable to least valuable - this ensures we always consider the best options first

Greedy Selection

Go through treasures in order, picking each one if it doesn't violate our constraints (bag space and category limits)

Track Constraints

Keep count of items per category and total items selected to ensure we never violate the rules

Key Takeaway

🎯 Key Insight: The greedy approach works because once items are sorted by value, selecting the highest available value that doesn't violate constraints is always the optimal choice. There's no advantage to saving space for lower-value items.

Asked in

G Google 42 a Amazon 31 f Meta 28 ⊞ Microsoft 19

The optimal approach uses a greedy strategy with sorting. First, sort items by value in descending order, then greedily select the highest-value items while tracking label counts with a hash map. This achieves O(n log n) time complexity and works because taking the highest available value that doesn't violate constraints is always optimal.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Approach (Optimal)	O(n log n)	O(n + k)	Sort items by value in descending order, then greedily select highest value items while respecting constraints
Brute Force (Generate All Subsets)	O(2^n * n)	O(n)	Generate all possible subsets and find the one with maximum value that satisfies constraints

Greedy Approach (Optimal) — Algorithm Steps

Create pairs of (value, label) and sort by value in descending order
Initialize a hash map to track count of items per label
Initialize counters for total items selected and total sum
Iterate through sorted items and select if constraints allow
Update counters and continue until numWanted items selected or no more valid items

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort by Value

Sort all items by value in descending order

Greedy Selection

Select highest value items that don't violate constraints

Track Constraints

Maintain count of items per label and total items selected

Code -

solution.c — C

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

typedef struct {
    int value;
    int label;
} Item;

int compare(const void* a, const void* b) {
    Item* itemA = (Item*)a;
    Item* itemB = (Item*)b;
    return itemB->value - itemA->value; // Descending order
}

int largestValsFromLabels(int* values, int valuesSize, int* labels, int labelsSize, int numWanted, int useLimit) {
    Item* items = (Item*)malloc(valuesSize * sizeof(Item));
    for (int i = 0; i < valuesSize; i++) {
        items[i].value = values[i];
        items[i].label = labels[i];
    }
    
    qsort(items, valuesSize, sizeof(Item), compare);
    
    int labelCount[1001] = {0}; // Assuming labels <= 1000
    int totalSum = 0;
    int selectedCount = 0;
    
    for (int i = 0; i < valuesSize; i++) {
        // Check if we can select this item
        if (selectedCount >= numWanted) break;
        if (labelCount[items[i].label] >= useLimit) continue;
        
        // Select this item
        labelCount[items[i].label]++;
        totalSum += items[i].value;
        selectedCount++;
    }
    
    free(items);
    return totalSum;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n log n) for sorting, O(n) for greedy selection, dominated by sorting

⚡ Linearithmic

Space Complexity

O(n + k)

O(n) for sorted pairs array, O(k) for label count hash map where k is unique labels

⚡ Linearithmic Space

26.4K Views

Medium Frequency

~18 min Avg. Time

892 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

Greedy Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler