पाइहटन में सबसे छोटी पर्याप्त टीम

मान लीजिए कि एक परियोजना के लिए हमारे पास आवश्यक कौशल की एक सूची है जिसे req_skills कहा जाता है, और लोगों की एक सूची है। यहाँ i-th People people[i] में उस व्यक्ति के कौशल की एक सूची है।

अब मान लीजिए कि एक पर्याप्त टीम को लोगों के एक समूह के रूप में परिभाषित किया गया है, जैसे कि req_skills में प्रत्येक आवश्यक कौशल के लिए, टीम में कम से कम एक व्यक्ति है जिसके पास वह कौशल है। हम प्रत्येक व्यक्ति की अनुक्रमणिका द्वारा इन टीमों का प्रतिनिधित्व कर सकते हैं:उदाहरण के तौर पर मान लीजिए कि टीम [0, 1, 3] है, यह लोगों [0], लोगों [1] और लोगों [3] के कौशल वाले लोगों का प्रतिनिधित्व करती है।

हमें सबसे छोटे संभव आकार की टीम ढूंढनी होगी।

आप किसी भी क्रम में उत्तर वापस कर सकते हैं। यह गारंटी है कि एक उत्तर मौजूद है।

इसलिए, यदि इनपुट req_skills =["जावा", "स्पंदन", "एंड्रॉइड"], लोग =[["जावा"], ["एंड्रॉइड"], ["स्पंदन", "एंड्रॉइड"]] जैसा है, तो आउटपुट [0,2]

इसे हल करने के लिए, हम इन चरणों का पालन करेंगे -

• डीपी:=एक नक्शा, कुंजी 0 के अनुरूप खाली सूची जोड़ें

• key :=एक नक्शा जैसे (मान, i) जहां मान req_skills से है और मैं संख्याएं हैं

• संख्या के लिए, व्यक्ति जोड़ी (i, p) लोगों को लेकर लोगों की सरणी से और उन्हें नंबर असाइन करें -

  • current_skill :=0

  • पी में कौशल के लिए

    • current_skill :=current_skill या 2^कुंजी[कौशल]

  • for (skill_set,members) जोड़ी dp की-वैल्यू पेयर में है -

    • Total_skill :=skills_set या current_skill

    • अगर Total_skill, Skill_set के समान है, तो -

      • निम्नलिखित भाग पर ध्यान न दें, अगले पुनरावृत्ति पर जाएं

    • अगर Total_skill dp के डू या साइज़ में नहीं है [total_skill]> सदस्यों का आकार + 1, तो

      • डीपी [total_skill] :=सदस्य + [i]

• वापसी डीपी [(1 <<लेन (req_skills))

आइए बेहतर समझ पाने के लिए निम्नलिखित कार्यान्वयन देखें -

उदाहरण

class Solution(object):
   def smallestSufficientTeam(self, req_skills, people):
      dp = {0:[]}
      key = {v:i for i,v in enumerate(req_skills)}
      for i,p in enumerate(people):
         current_skill = 0
         for skill in p:
         current_skill |= 1<< key[skill]
      for skill_set, members in dp.items():
         total_skill = skill_set|current_skill
         if total_skill == skill_set:
            continue
         if total_skill not in dp or len(dp[total_skill])>
len(members)+1:
            dp[total_skill] = members + [i]
      return dp[(1<<len(req_skills)) - 1]
ob = Solution()
print(ob.smallestSufficientTeam(["java","flutter","android"],
[["java"],["android"],["flutter","android"]]))

इनपुट

["java","flutter","android"]
[["java"],["android"],["flutter","android"]]

आउटपुट

[0,2]