Maximum Matching of Players With Trainers - Problem

You are given a 0-indexed integer array players, where players[i] represents the ability of the i^th player. You are also given a 0-indexed integer array trainers, where trainers[j] represents the training capacity of the j^th trainer.

The i^th player can match with the j^th trainer if the player's ability is less than or equal to the trainer's training capacity. Additionally, the i^th player can be matched with at most one trainer, and the j^th trainer can be matched with at most one player.

Return the maximum number of matchings between players and trainers that satisfy these conditions.

Input & Output

Example 1 — Basic Case

$ Input: players = [4,7,9], trainers = [8,2,5,8]

› Output: 2

💡 Note: We can match player 4 with trainer 5 (4 ≤ 5) and player 7 with trainer 8 (7 ≤ 8). Player 9 cannot be matched since no remaining trainer has capacity ≥ 9.

Example 2 — All Players Match

$ Input: players = [1,1,1], trainers = [10]

› Output: 1

💡 Note: Only one trainer available, so we can match at most one player. All players have ability 1 ≤ 10, but each trainer can only match with one player.

Example 3 — No Matches Possible

$ Input: players = [10,20,30], trainers = [5,6,7]

› Output: 0

💡 Note: No player can be matched because every player's ability exceeds every trainer's capacity.

Constraints

1 ≤ players.length, trainers.length ≤ 10⁵
1 ≤ players[i], trainers[j] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15 f Meta 12

The key insight is that greedy matching works optimally when both arrays are sorted. Sort both players and trainers, then use two pointers to match each player with the weakest available trainer that can handle them. Best approach is Greedy with Sorting: Time: O(n log n), Space: O(1)

Common Approaches

✓ Bit Manipulation

⏱️ Time: N/A Space: N/A

Optimized

⏱️ Time: N/A Space: N/A

Brute Force - Try All Combinations

⏱️ Time: O(2^(n×m)) Space: O(n×m)

Try every possible combination of player-trainer pairs and count how many valid matchings we can make. This involves checking all subsets of possible pairs.

Greedy with Sorting

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

Sort players in ascending order and trainers in ascending order. Use two pointers to greedily match each player with the weakest available trainer that can handle them.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int solution(char words[][21], int n) {
    int maxProduct = 0;
    
    // Convert each word to a bitmask
    int masks[300];
    for (int i = 0; i < n; i++) {
        int mask = 0;
        for (int j = 0; words[i][j]; j++) {
            mask |= 1 << (words[i][j] - 'a');
        }
        masks[i] = mask;
    }
    
    // Check all pairs using bitwise AND
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            if ((masks[i] & masks[j]) == 0) {  // No common letters
                int product = strlen(words[i]) * strlen(words[j]);
                if (product > maxProduct) {
                    maxProduct = product;
                }
            }
        }
    }
    
    return maxProduct;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    char words[300][21];
    int n = 0;
    
    // Parse JSON array format like ["word1","word2",...]
    char *ptr = line;
    while (*ptr && *ptr != '[') ptr++; // Find opening bracket
    if (*ptr) ptr++; // Skip opening bracket
    
    while (*ptr && *ptr != ']' && n < 300) {
        // Skip whitespace and commas
        while (*ptr && (*ptr == ' ' || *ptr == ',' || *ptr == '\n' || *ptr == '\r')) ptr++;
        
        if (*ptr == '"') {
            ptr++; // Skip opening quote
            int len = 0;
            while (*ptr && *ptr != '"' && len < 20) {
                words[n][len++] = *ptr++;
            }
            words[n][len] = '\0';
            if (*ptr == '"') ptr++; // Skip closing quote
            n++;
        } else if (*ptr && *ptr != ']') {
            ptr++; // Skip any other character
        }
    }
    
    int result = solution(words, n);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

32.5K Views

Medium Frequency

~15 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