leetcode - 1125. Smallest Sufficient Team

**LeetCode1125. Smallest Sufficient Team**

**题目描述**

给定一个目标值 `target`,以及一个团队成员的技能列表 `skills`。每个团队成员都有一个唯一的 ID 和一组技能。我们需要找到最小的团队集合，使得所有团队成员的技能加起来能够覆盖 `target` 所需的技能。

**示例1**

输入：`target = "a", skills = ["b","c"]`

输出：`[2]`

解释：只有 ID 为2 的团队成员有技能 'a'，所以最小的团队集合是 `[2]`。

**示例2**

输入：`target = "ab", skills = ["b","c"]`

输出：`[-1,-2,-3]`

解释：ID 为 -1、-2 和 -3 的团队成员分别有技能 'a'、'b' 和 'c'，所以最小的团队集合是 `[-1,-2,-3]`。

**示例3**

输入：`target = "abc", skills = ["b","c"]`

输出：`[-1,1,2]`

解释：ID 为 -1、1 和2 的团队成员分别有技能 'a'、'b' 和 'c'，所以最小的团队集合是 `[-1,1,2]`。

**示例4**

输入：`target = "ab", skills = ["a","b"]`

输出：`[1,2]`

解释：ID 为1 和2 的团队成员分别有技能 'a' 和 'b'，所以最小的团队集合是 `[1,2]`。

**示例5**

输入：`target = "abc", skills = ["a","b"]`

输出：`[-1,-2,3]`

解释：ID 为 -1、-2 和3 的团队成员分别有技能 'a'、'b' 和 'c'，所以最小的团队集合是 `[-1,-2,3]`。

**解决方案**

我们可以使用一个哈希表来存储每个团队成员的技能。然后，我们可以遍历 `target` 的每个字符，并检查是否有团队成员具有该字符所需的技能。如果有，则将其添加到结果中。

class Solution:
 def smallestSufficientTeam(self, target: str, skills: List[str]) -> List[int]:
 n = len(target)
 m = len(skills)

 # Initialize a dictionary to store the skills of each team member skill_dict = {i: set() for i in range(1, m +2)}

 # Add the skills of each team member to the dictionary for i in range(m):
 skill_dict[i +1].add(skills[i])

 # Initialize a list to store the result res = []

 # Iterate over the target string for i in range(n):
 # Check if there is a team member with the current character's skills found = False for j in range(1, m +2):
 if skill_dict[j].issuperset({target[i]}):
 res.append(j)
 found = True break # If not, add all team members to the result if not found:
 res.extend([j for j in range(1, m +2)])

 return res

**注释**

* 我们首先初始化一个字典 `skill_dict` 来存储每个团队成员的技能。
* 然后，我们遍历 `target` 的每个字符，并检查是否有团队成员具有该字符所需的技能。如果有，则将其添加到结果中。
* 如果没有找到匹配的团队成员，我们会将所有团队成员都添加到结果中。

**时间复杂度**

* 初始化字典 `skill_dict` 的时间复杂度为 O(m)，其中 m 是技能列表的长度。
* 遍历 `target` 的每个字符并检查是否有匹配的团队成员的时间复杂度为 O(n * m)。
* 总体而言，时间复杂度为 O(n * m)。

**空间复杂度**

* 初始化字典 `skill_dict` 需要 O(m) 的空间。
* 遍历 `target` 的每个字符并检查是否有匹配的团队成员需要 O(1) 的空间。
* 总体而言，空间复杂度为 O(m)。