Watch 10 video solutions for Smallest Sufficient Team, a hard level problem involving Array, Dynamic Programming, Bit Manipulation. This walkthrough by Aryan Mittal has 7,264 views views. Want to try solving it yourself? Practice on FleetCode or read the detailed text solution.
In a project, you have a list of required skills req_skills, and a list of people. The ith 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.
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.
Example 1:
Input: req_skills = ["java","nodejs","reactjs"], people = [["java"],["nodejs"],["nodejs","reactjs"]] Output: [0,2]
Example 2:
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]
Constraints:
1 <= req_skills.length <= 161 <= req_skills[i].length <= 16req_skills[i] consists of lowercase English letters.req_skills are unique.1 <= people.length <= 600 <= people[i].length <= 161 <= people[i][j].length <= 16people[i][j] consists of lowercase English letters.people[i] are unique.people[i] is a skill in req_skills.Problem Overview: Given a list of required skills and a list of people with subsets of those skills, find the smallest group of people whose combined skills cover every requirement. The output is the indices of people forming that minimum team.
Approach 1: Backtracking (Exponential)
This approach tries every combination of people and checks whether their combined skills cover all required skills. Represent each person's skills as a bitmask, then recursively decide whether to include or skip each person. During recursion, maintain the current skill mask and the team members selected so far. If the mask covers all skills, update the best solution if the team is smaller. Time complexity is O(2^n * m) where n is the number of people and m is the number of skills, since every subset may be explored and skill masks are merged using bit operations. Space complexity is O(n) due to recursion depth and temporary team storage. This method demonstrates the brute-force search space but becomes impractical as the number of people grows.
Approach 2: Bitmask with Dynamic Programming (O(n · 2^m))
The optimized approach encodes each skill as a bit position and represents a person's skills using a bitmask. The goal becomes covering the full skill mask (1 << m) - 1. Use dynamic programming where the key is a skill mask and the value is the smallest team that achieves it. Start with dp[0] = []. For each person, compute their skill mask and iterate over existing DP states. Combine the current mask with the person's mask using bitwise OR. If this new mask can be achieved with fewer people than previously recorded, update the DP entry with the new team. Because there are at most 2^m skill states and each person updates them once, the time complexity is O(n · 2^m) and space complexity is O(2^m). Bit operations make state transitions extremely fast.
This solution relies heavily on bit manipulation and bitmask representations. Skills are compressed into integers, allowing union operations using a single OR instruction. The DP map effectively tracks the smallest team for every possible skill combination, ensuring the final result is minimal.
Recommended for interviews: The Bitmask Dynamic Programming approach is what interviewers typically expect. It shows you understand state compression and how to model subset coverage efficiently. Backtracking demonstrates the brute-force reasoning, but recognizing the small skill limit and converting the problem into a 2^m DP is the key insight that signals strong problem-solving ability.
| Approach | Time | Space | When to Use |
|---|---|---|---|
| Backtracking | O(2^n * m) | O(n) | Conceptual brute force for small inputs or when demonstrating subset exploration |
| Bitmask Dynamic Programming | O(n · 2^m) | O(2^m) | Optimal solution when the number of required skills is small (≤16) |