Smallest Sufficient Team

Smallest Sufficient Team - Problem

In a project, you have a list of required skills req_skills, and a list of people. The i-th person people[i] contains a list of skills that the person has.

Consider a sufficient team: a set of people such that for every required skill in req_skills, there is at least one person in the team who has that skill.

We can represent these teams by the index of each person. For example, team = [0, 1, 3] represents the people with skills people[0], people[1], and people[3].

Return any sufficient team of the smallest possible size, represented by the index of each person. You may return the answer in any order. It is guaranteed an answer exists.

Input & Output

Example 1 — Basic Team Formation

$ Input: req_skills = ["java","nodejs","reactjs"], people = [["java"],["nodejs"],["nodejs","reactjs"]]

› Output: [0,2]

💡 Note: Person 0 has java, Person 2 has nodejs and reactjs. Together they cover all required skills [java, nodejs, reactjs]

Example 2 — Minimal Team

$ Input: req_skills = ["algorithms","math","java","reactjs","csharp","aws"], people = [["algorithms","math","java"],["algorithms","math","reactjs"],["java","csharp","aws"],["reactjs","csharp"],["csharp","math"],["aws","java"]]

› Output: [1,2]

💡 Note: Person 1 covers [algorithms,math,reactjs] and Person 2 covers [java,csharp,aws]. Together they have all 6 skills.

Example 3 — Single Person Team

$ Input: req_skills = ["cooking"], people = [["cooking","baking"],["art"]]

› Output: [0]

💡 Note: Only Person 0 has the cooking skill, so they form the minimal sufficient team

Constraints

1 ≤ req_skills.length ≤ 16
1 ≤ people.length ≤ 60
1 ≤ people[i].length, req_skills[i].length, people[i][j].length ≤ 16
Elements of req_skills are distinct
req_skills[i] and people[i][j] consist of lowercase English letters only
Every skill in people[i] is also in req_skills
It is guaranteed an answer exists

Visualization

Tap to expand

Asked in

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

The key insight is to use bitmasks to efficiently represent skill sets and dynamic programming to build minimal teams. Convert each skill to a bit position and each person's skills to a bitmask. Use DP where dp[mask] represents the smallest team covering skills in the mask. Best approach is Bitmask DP with Time: O(n × 2ᵐ), Space: O(2ᵐ) where n is people count and m is skills count.

Common Approaches

✓ Bitmask Dynamic Programming

⏱️ Time: O(n × 2ᵐ) Space: O(2ᵐ)

Convert skills to bitmasks where each bit represents a skill. Use dynamic programming where dp[mask] represents the smallest team that covers the skills represented by the mask. Build up solutions incrementally.

Brute Force - Try All Combinations

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

This approach generates all possible subsets of people and checks each one to see if it covers all required skills. We start with the smallest team size and work our way up until we find a valid team.

Bitmask Dynamic Programming — Algorithm Steps

Map each skill to a bit position
Convert each person's skills to a bitmask
Use DP where dp[mask] = smallest team covering skills in mask
Build solution by adding one person at a time

Visualization

Tap to expand

Step-by-Step Walkthrough

Convert to Bits

Map each skill to a bit position, convert people to bitmasks

DP States

dp[mask] = smallest team covering skills in mask

Build Solution

Add people incrementally until all skills covered

Code -

solution.c — C

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

#define MAX_SKILLS 16
#define MAX_PEOPLE 60
#define MAX_MASK (1 << MAX_SKILLS)

typedef struct {
    int size;
    int team[MAX_PEOPLE];
    int team_len;
    bool exists;
} DPState;

static DPState dp[MAX_MASK];

int findSkillIndex(char** req_skills, int req_size, char* skill) {
    for (int i = 0; i < req_size; i++) {
        if (strcmp(req_skills[i], skill) == 0) {
            return i;
        }
    }
    return -1;
}

int* solution(char** req_skills, int req_size, char*** people, int* people_sizes, int people_count, int* returnSize) {
    int m = req_size;
    int n = people_count;
    
    if (m == 0 || n == 0) {
        *returnSize = 0;
        return NULL;
    }
    
    int targetMask = (1 << m) - 1;
    
    // Convert people's skills to bitmasks
    int peopleMasks[MAX_PEOPLE];
    for (int i = 0; i < n; i++) {
        int mask = 0;
        for (int j = 0; j < people_sizes[i]; j++) {
            int skillIdx = findSkillIndex(req_skills, req_size, people[i][j]);
            if (skillIdx != -1) {
                mask |= (1 << skillIdx);
            }
        }
        peopleMasks[i] = mask;
    }
    
    // Initialize DP
    for (int i = 0; i < MAX_MASK; i++) {
        dp[i].exists = false;
    }
    
    dp[0].exists = true;
    dp[0].size = 0;
    dp[0].team_len = 0;
    
    // DP iteration
    for (int mask = 0; mask < (1 << m); mask++) {
        if (!dp[mask].exists) continue;
        
        int currSize = dp[mask].size;
        
        // Try adding each person
        for (int i = 0; i < n; i++) {
            int newMask = mask | peopleMasks[i];
            int newSize = currSize + 1;
            
            // Update if we found a better solution
            if (!dp[newMask].exists || dp[newMask].size > newSize) {
                dp[newMask].exists = true;
                dp[newMask].size = newSize;
                dp[newMask].team_len = dp[mask].team_len + 1;
                
                // Copy previous team
                for (int j = 0; j < dp[mask].team_len; j++) {
                    dp[newMask].team[j] = dp[mask].team[j];
                }
                // Add new person
                dp[newMask].team[dp[mask].team_len] = i;
            }
        }
    }
    
    if (!dp[targetMask].exists) {
        *returnSize = 0;
        return NULL;
    }
    
    *returnSize = dp[targetMask].team_len;
    int* result = (int*)malloc((*returnSize) * sizeof(int));
    for (int i = 0; i < *returnSize; i++) {
        result[i] = dp[targetMask].team[i];
    }
    
    return result;
}

int parseStringArray(char* line, char** arr) {
    int count = 0;
    char* ptr = strchr(line, '[');
    if (!ptr) return 0;
    ptr++;
    
    while (*ptr && *ptr != ']') {
        while (*ptr == ' ' || *ptr == ',') ptr++;
        if (*ptr == '"') {
            ptr++;
            char* start = ptr;
            while (*ptr && *ptr != '"') ptr++;
            int len = ptr - start;
            arr[count] = (char*)malloc(len + 1);
            strncpy(arr[count], start, len);
            arr[count][len] = '\0';
            count++;
            if (*ptr == '"') ptr++;
        } else if (*ptr == ']') {
            break;
        } else {
            ptr++;
        }
    }
    return count;
}

int parse2DStringArray(char* line, char*** arr, int* sizes) {
    int count = 0;
    char* ptr = strchr(line, '[');
    if (!ptr) return 0;
    ptr++;
    
    while (*ptr && count < MAX_PEOPLE) {
        while (*ptr == ' ' || *ptr == ',') ptr++;
        if (*ptr == '[') {
            arr[count] = (char**)malloc(MAX_SKILLS * sizeof(char*));
            ptr++;
            int innerCount = 0;
            
            while (*ptr && *ptr != ']') {
                while (*ptr == ' ' || *ptr == ',') ptr++;
                if (*ptr == '"') {
                    ptr++;
                    char* start = ptr;
                    while (*ptr && *ptr != '"') ptr++;
                    int len = ptr - start;
                    arr[count][innerCount] = (char*)malloc(len + 1);
                    strncpy(arr[count][innerCount], start, len);
                    arr[count][innerCount][len] = '\0';
                    innerCount++;
                    if (*ptr == '"') ptr++;
                } else if (*ptr == ']') {
                    break;
                } else {
                    ptr++;
                }
            }
            
            sizes[count] = innerCount;
            count++;
            if (*ptr == ']') ptr++;
        } else if (*ptr == ']') {
            break;
        } else {
            ptr++;
        }
    }
    return count;
}

int main() {
    char line1[10000], line2[10000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    // Remove newlines
    line1[strcspn(line1, "\n")] = 0;
    line2[strcspn(line2, "\n")] = 0;
    
    char** req_skills_ptr = (char**)malloc(MAX_SKILLS * sizeof(char*));
    int req_size = parseStringArray(line1, req_skills_ptr);
    
    char*** people_ptr = (char***)malloc(MAX_PEOPLE * sizeof(char**));
    int people_sizes[MAX_PEOPLE];
    int people_count = parse2DStringArray(line2, people_ptr, people_sizes);
    
    int returnSize;
    int* result = solution(req_skills_ptr, req_size, people_ptr, people_sizes, people_count, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    // Cleanup
    if (result) free(result);
    for (int i = 0; i < req_size; i++) {
        free(req_skills_ptr[i]);
    }
    free(req_skills_ptr);
    for (int i = 0; i < people_count; i++) {
        for (int j = 0; j < people_sizes[i]; j++) {
            free(people_ptr[i][j]);
        }
        free(people_ptr[i]);
    }
    free(people_ptr);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × 2ᵐ)

n people times 2ᵐ possible skill combinations (m = number of skills)

✓ Linear Growth

Space Complexity

O(2ᵐ)

DP array storing optimal team for each skill combination

✓ Linear Space

40.8K Views

Medium Frequency

~35 min Avg. Time

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

Bitmask Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler