Smallest Sufficient Team - Practice Coding Problems

Smallest Sufficient Team - Problem

Team Building Challenge

Imagine you're a project manager who needs to assemble the smallest possible team for a critical project. You have a list of req_skills that are absolutely necessary for the project's success, and a pool of candidates where each person has their own unique set of skills.

Your mission: Find the minimum number of people needed to cover ALL required skills.

For example, if your project needs ["java", "nodejs", "reactjs"] and you have candidates with skills like:
• Person 0: ["java"]
• Person 1: ["nodejs"]
• Person 2: ["nodejs", "reactjs"]

The optimal team would be [0, 2] - just 2 people to cover all 3 required skills!

Goal: Return the indices of team members in the smallest sufficient team. Any valid minimum-size team is acceptable.

Input & Output

example_1.py — Basic Team Assembly

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

› Output: [0,2]

💡 Note: Person 0 provides Java, Person 2 provides both NodeJS and ReactJS. Together they cover all required skills with just 2 team members.

example_2.py — Overlapping Skills

$ 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 provide all 6 required skills efficiently.

example_3.py — Single Person Solution

$ Input: req_skills = ["python","django"] people = [["python"],["django"],["python","django","flask"]]

› Output: [2]

💡 Note: Person 2 alone has both required skills (python and django), making them a complete one-person team. Even though they have an extra skill (flask), they're still optimal.

Visualization

Tap to expand

Understanding the Visualization

Map Powers to Bits

Each superpower gets a unique bit position - Java is bit 0, Python is bit 1, React is bit 2

Heroes Become Binary

Each hero's power set becomes a binary number - Hero with Java+Python becomes '011'

Smart Team Building

Use DP to systematically build teams, combining power sets with bitwise OR operations

Find Optimal Squad

The smallest team covering all powers (111 in binary) is our answer!

Key Takeaway

🎯 Key Insight: By representing skill sets as bitmasks, we transform set operations into ultra-fast bitwise operations, making the solution both elegant and efficient!

Time & Space Complexity

Time Complexity

⏱️

O(people × 2^skills)

For each of 2^skills possible coverage masks, we check each person

✓ Linear Growth

Space Complexity

O(2^skills × people)

DP array stores best team for each skill coverage pattern

✓ Linear Space

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 and people[i] consist of lowercase English letters
It is guaranteed an answer exists

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 29 f Meta 22

The optimal solution uses dynamic programming with bitmasks to represent skill coverage efficiently. By mapping each skill to a bit position and using bitwise OR operations, we can quickly combine skill sets and find the minimum team size in O(people × 2^skills) time.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming + Bitmask (Optimal)	O(people × 2^skills)	O(2^skills × people)	Use bitmasks to represent skill coverage and DP to find minimal teams
Brute Force (Try All Combinations)	O(2^n × m)	O(m)	Generate all possible team combinations and find the smallest valid one

Dynamic Programming + Bitmask (Optimal) — Algorithm Steps

Map each required skill to a bit position (0 to n-1)
Convert each person's skills to a bitmask
Initialize DP array where dp[mask] = smallest team covering those skills
For each skill coverage mask, try adding each person to extend coverage
Return the team stored in dp[(1 << num_skills) - 1]

Visualization

Tap to expand

Step-by-Step Walkthrough

Map Skills to Bits

Assign each skill a bit position (Java=0, Python=1, React=2)

Convert People to Masks

Each person becomes a binary number representing their skills

Build DP Table

For each skill combination, find the smallest team that covers it

Combine with OR

Use bitwise OR to combine skill sets efficiently

Code -

solution.c — C

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

int* smallestSufficientTeam(char** reqSkills, int reqSkillsSize, char*** people, int peopleSize, int* peopleColSize, int* returnSize) {
    // Map skills to bit positions
    int skillToBit[16]; // Assuming max 16 skills
    for (int i = 0; i < reqSkillsSize; i++) {
        skillToBit[i] = i; // Simple mapping for demo
    }
    
    // Convert people's skills to bitmasks
    int* peopleMasks = (int*)calloc(peopleSize, sizeof(int));
    for (int i = 0; i < peopleSize; i++) {
        for (int j = 0; j < peopleColSize[i]; j++) {
            for (int k = 0; k < reqSkillsSize; k++) {
                if (strcmp(people[i][j], reqSkills[k]) == 0) {
                    peopleMasks[i] |= 1 << k;
                    break;
                }
            }
        }
    }
    
    int numSkills = reqSkillsSize;
    int target = (1 << numSkills) - 1;
    
    // dp[mask] = smallest team that covers skills in mask
    int** dp = (int**)malloc((1 << numSkills) * sizeof(int*));
    int* dpSizes = (int*)calloc(1 << numSkills, sizeof(int));
    
    // Initialize
    for (int i = 0; i < (1 << numSkills); i++) {
        dp[i] = NULL;
        dpSizes[i] = -1; // -1 means not reachable
    }
    dp[0] = (int*)malloc(peopleSize * sizeof(int));
    dpSizes[0] = 0;
    
    for (int mask = 0; mask < (1 << numSkills); mask++) {
        if (dpSizes[mask] == -1) continue;
        
        for (int personIdx = 0; personIdx < peopleSize; personIdx++) {
            int newMask = mask | peopleMasks[personIdx];
            if (dpSizes[newMask] == -1 || dpSizes[mask] + 1 < dpSizes[newMask]) {
                if (dp[newMask] == NULL) {
                    dp[newMask] = (int*)malloc(peopleSize * sizeof(int));
                }
                
                // Copy previous team and add new person
                for (int k = 0; k < dpSizes[mask]; k++) {
                    dp[newMask][k] = dp[mask][k];
                }
                dp[newMask][dpSizes[mask]] = personIdx;
                dpSizes[newMask] = dpSizes[mask] + 1;
            }
        }
    }
    
    *returnSize = dpSizes[target];
    int* result = NULL;
    if (*returnSize > 0) {
        result = (int*)malloc(*returnSize * sizeof(int));
        for (int i = 0; i < *returnSize; i++) {
            result[i] = dp[target][i];
        }
    }
    
    // Cleanup
    for (int i = 0; i < (1 << numSkills); i++) {
        free(dp[i]);
    }
    free(dp);
    free(dpSizes);
    free(peopleMasks);
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(people × 2^skills)

For each of 2^skills possible coverage masks, we check each person

✓ Linear Growth

Space Complexity

O(2^skills × people)

DP array stores best team for each skill coverage pattern

✓ Linear Space

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 and people[i] consist of lowercase English letters
It is guaranteed an answer exists

67.2K Views

Medium-High Frequency

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Dynamic Programming + Bitmask (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler