## Algorithm

Problem Name: 1090. Largest Values From Labels

There is a set of `n` items. You are given two integer arrays `values` and `labels` where the value and the label of the `ith` element are `values[i]` and `labels[i]` respectively. You are also given two integers `numWanted` and `useLimit`.

Choose a subset `s` of the `n` elements such that:

• The size of the subset `s` is less than or equal to `numWanted`.
• There are at most `useLimit` items with the same label in `s`.

The score of a subset is the sum of the values in the subset.

Return the maximum score of a subset `s`.

Example 1:

```Input: values = [5,4,3,2,1], labels = [1,1,2,2,3], numWanted = 3, useLimit = 1
Output: 9
Explanation: The subset chosen is the first, third, and fifth items.
```

Example 2:

```Input: values = [5,4,3,2,1], labels = [1,3,3,3,2], numWanted = 3, useLimit = 2
Output: 12
Explanation: The subset chosen is the first, second, and third items.
```

Example 3:

```Input: values = [9,8,8,7,6], labels = [0,0,0,1,1], numWanted = 3, useLimit = 1
Output: 16
Explanation: The subset chosen is the first and fourth items.
```

Constraints:

• `n == values.length == labels.length`
• `1 <= n <= 2 * 104`
• `0 <= values[i], labels[i] <= 2 * 104`
• `1 <= numWanted, useLimit <= n`

## Code Examples

### #1 Code Example with Javascript Programming

```Code - Javascript Programming```

``````
const largestValsFromLabels = function(values, labels, num_wanted, use_limit) {
return Object.entries(
labels.reduce((ret, l, i) => {
ret[l] = (ret[l] || []).concat(values[i])
return ret
}, {})
)
.reduce(
(candi, [k, vals]) =>
candi.concat(vals.sort((a, b) => b - a).slice(0, use_limit)),
[]
)
.sort((a, b) => b - a)
.slice(0, num_wanted)
.reduce((ret, n) => ret + n, 0)
};
``````
Copy The Code &

Input

cmd
values = [5,4,3,2,1], labels = [1,1,2,2,3], numWanted = 3, useLimit = 1

Output

cmd
9

### #2 Code Example with Python Programming

```Code - Python Programming```

``````
class Solution:
def largestValsFromLabels(self, values: List[int], labels: List[int], num_wanted: int, use_limit: int) -> int:
cnt = collections.defaultdict(int)
heap = [[-a, b] for a, b in zip(values, labels)]
heapq.heapify(heap)
use = sm =0
while use < num_wanted and heap:
a, b = heapq.heappop(heap)
if cnt[b] < use_limit:
sm -= a
use += 1
cnt[b] += 1
return sm
``````
Copy The Code &

Input

cmd
values = [5,4,3,2,1], labels = [1,1,2,2,3], numWanted = 3, useLimit = 1

Output

cmd
9