[Swift]LeetCode1125. 最小的必要团队 | Smallest Sufficient Team

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/11179545.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

热烈欢迎，请直接点击！！！

进入博主App Store主页，下载使用各个作品！！！

注：博主将坚持每月上线一个新app！！！

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 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. 

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 <= 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] are (respectively) distinct.
• req_skills[i][j], people[i][j][k] are lowercase English letters.
• It is guaranteed a sufficient team exists.

---

作为项目经理，你规划了一份需求的技能清单 req_skills，并打算从备选人员名单 people 中选出些人组成一个「必要团队」（ 编号为 i 的备选人员 people[i] 含有一份该备选人员掌握的技能列表）。

所谓「必要团队」，就是在这个团队中，对于所需求的技能列表 req_skills 中列出的每项技能，团队中至少有一名成员已经掌握。

我们可以用每个人的编号来表示团队中的成员：例如，团队 team = [0, 1, 3] 表示掌握技能分别为 people[0]，people[1]，和 people[3] 的备选人员。

请你返回 任一 规模最小的必要团队，团队成员用人员编号表示。你可以按任意顺序返回答案，本题保证答案存在。 

示例 1：

输入：req_skills = ["java","nodejs","reactjs"], people = [["java"],["nodejs"],["nodejs","reactjs"]]
输出：[0,2]

示例 2：

输入：req_skills = ["algorithms","math","java","reactjs","csharp","aws"], people = [["algorithms","math","java"],["algorithms","math","reactjs"],["java","csharp","aws"],["reactjs","csharp"],["csharp","math"],["aws","java"]]
输出：[1,2] 

提示：

• 1 <= req_skills.length <= 16
• 1 <= people.length <= 60
• 1 <= people[i].length, req_skills[i].length, people[i][j].length <= 16
• req_skills 和 people[i] 中的元素分别各不相同
• req_skills[i][j], people[i][j][k] 都由小写英文字母组成
• 本题保证「必要团队」一定存在

---

132ms

class Solution {
    func smallestSufficientTeam(_ req_skills: [String], _ people: [[String]]) -> [Int] {
        var solution = Set<Int>()
        var setPeople = people.map { Set($0) }
        var skillToPeopleDict = [String:[Int]]()
        
        for (i, personSet) in setPeople.enumerated() {
            for (j, anotherPersonSet) in setPeople.enumerated() where i != j {
                if personSet.isSubset(of: anotherPersonSet) {
                    setPeople[i] = []
                    break
                }
            }
        }
        
        for (i, personSet) in setPeople.enumerated() {
            for skill in personSet {
                skillToPeopleDict[skill] = (skillToPeopleDict[skill] ?? []) + [i]
            }
        }
        
        return smallestSufficientTeam(req_skills, skillToPeopleDict, setPeople, 0, [], [])
    }
    
    func smallestSufficientTeam(_ skills: [String], 
                                _ skillToPeopleDict: [String:[Int]],
                                _ people: [Set<String>],
                                _ i: Int,
                                _ totalSkillsAdded: Set<String>,
                                _ soFar: [Int]) -> [Int] {
        if i >= skills.count { return Array(soFar) }
        
        let nextSkill = skills[i]
        
        if totalSkillsAdded.contains(nextSkill) {
            return smallestSufficientTeam(skills, skillToPeopleDict, people, i+1, totalSkillsAdded, soFar)   
        }
        
        var solution = [Int]()
        
        for person in skillToPeopleDict[nextSkill] ?? [] {
            let personSkills = people[person]
            let next = smallestSufficientTeam(skills, 
                                              skillToPeopleDict, 
                                              people, 
                                              i+1, 
                                              totalSkillsAdded.union(personSkills),
                                              soFar + [person])   
            
            if !next.isEmpty {
                if solution.isEmpty {
                    solution = next
                } else if next.count < solution.count {
                    solution = next
                }
            }
        }
        
        return solution
    }
}

---

156ms

class Solution {
    func smallestSufficientTeam(_ req_skills: [String], _ people: [[String]]) -> [Int] {
        let req_skills_len = req_skills.count, people_len = people.count
        var map = [String: Int]()
        for i in 0..<req_skills_len {
            map[req_skills[i]] = i
        }
        var dp = [Int: [Int]]()
        dp[0] = [Int]()

        for i in 0..<people_len {
            var his_skill = 0
            for skill in people[i] {
                if map[skill] != nil {
                    his_skill |= 1<<map[skill]!
                }
            }
            for (skill_set, need) in dp {
                let with_him = skill_set | his_skill
                if with_him == skill_set { continue }
                if dp[with_him] == nil || dp[with_him]!.count > need.count+1 {
                    var sets = need
                    sets.append(i)
                    dp[with_him] = sets
                }
            }
        }
        return dp[1<<req_skills_len - 1, default: [Int]()]
    }
}

---

180ms

class Solution {
    func smallestSufficientTeam(_ req_skills: [String], _ people: [[String]]) -> [Int] {
        let n = req_skills.count 
        let m = people.count 
        var dict = [String: Int]()
        for i in 0..<req_skills.count {
            let skill = req_skills[i]
            dict[skill] = i
        }
        
        var dp = [Int: [Int]]()
        dp[0] = [Int]()
        
        for (idx, skills) in people.enumerated() {
            var his_skill = 0
            for skill in skills {
                his_skill |= 1 << dict[skill]!
            }
            
            for (skill_set, need) in dp {
                let with_him = skill_set | his_skill
                if with_him == skill_set { continue }
                if dp[with_him] == nil || dp[with_him]!.count > need.count + 1 {
                    dp[with_him] = need + [idx]
                }
            }
        }
        return dp[(1<<n) - 1]!
    }
}

---

296ms

class Solution {
    struct Team {
        public let people: [Int]
          public let required: Set<String>

        init(required: [String]) {
             self.people = []
               self.required = Set<String>(required)
        }

        init(team: Team, adding idx: Int, with skills: [String]) {
            self.people = team.people + [ idx ]
               self.required = team.required.subtracting(skills)
        }
    }

    private func completeTeam(_ team: Team, _ people: [[String]], _ bySkill: [String:[Int]]) -> Team? {
        guard let skill = team.required.first else {
            return team
        }
        guard let withSkill = bySkill[skill] else {
            return nil
        }

        var bestTeam: Team?
        var requiredUsed = Set<Set<String>>()
        for idx in withSkill {
            let tmpTeam = Team(team: team, adding: idx, with: people[idx])
            if requiredUsed.contains(tmpTeam.required) {
                continue
            }
            requiredUsed.insert(tmpTeam.required)
            
            guard let tmpResult = self.completeTeam(tmpTeam, people, bySkill) else {
                continue
            }
            if bestTeam == nil || bestTeam!.people.count > tmpResult.people.count {
                bestTeam = tmpResult
            }
        }
        return bestTeam
    }

    func smallestSufficientTeam(_ req_skills: [String], _ people: [[String]]) -> [Int] {
        guard req_skills.count > 0 && people.count > 0 else {
            return []
        }

        var bySkill = [String:[Int]]()
        let team = Team(required: req_skills)
        for (idx, skills) in people.enumerated() {
            for skill in team.required.intersection(skills) {
                  bySkill[skill, default: []].append(idx)
            }
        }

        if let result = self.completeTeam(team, people, bySkill) {
            return result.people
        } else {
            return []
        }
    }
}

---

Runtime: 652 ms

Memory Usage: 82.7 MB

class Solution {
    func smallestSufficientTeam(_ req_skills: [String], _ people: [[String]]) -> [Int] {
        var inf:Int = 0x3f3f3f3f
        let m:Int = req_skills.count
        let n:Int = people.count
        var all:Int = 1 << m
        var skill_id:[String:Int] = [String:Int]()
        var k:Int = 0
        for skill in req_skills
        {
            skill_id[skill] = k
            k += 1
        }
        var skillset:[Int] = [Int](repeating:0,count:n)
        for i in 0..<n
        {
            var st:Int = 0
            for skill in people[i]
            {
                st |= 1 << skill_id[skill]!
            }
            skillset[i] = st
        }
        var dp:[[Int]] = [[Int]](repeating:[Int](repeating:inf,count:all),count:n + 1)
        var last:[[Int]] = [[Int]](repeating:[Int](repeating:0,count:all),count:n + 1)
        dp[0][0] = 0
        for i in 1...n
        {
            for j in 0..<all
            {
                if dp[i][j] > dp[i - 1][j]
                {
                    dp[i][j] = dp[i - 1][j]
                    last[i][j] = j
                }
                if dp[i - 1][j] + 1 < dp[i][j | skillset[i - 1]]
                {
                    dp[i][j | skillset[i - 1]] = dp[i - 1][j] + 1
                    last[i][j | skillset[i - 1]] = j
                }
            }
        }
        var i:Int = n
        var j:Int = all - 1
        var res:[Int] = [Int]()
        while(i != 0)
        {
            if last[i][j] != j
            {
                res.insert(i - 1,at:0)
            }
            j = last[i][j]
            i -= 1
        }
        return res      
    }
}