बाधा संतुष्टि समस्या एक बाधा याद आ रही है

Question

मैं विश्वविद्यालय में एक लैब प्रैक्टिस ट्यूटर हूं, जो पिछले साल के छात्र टिप्पणियों पर आधारित था, हम उन्हें संबोधित करने के लिए मेरे बॉस और मैं चाहते थे। मेरे बॉस ने एक सी स्क्रिप्ट लिखने के साथ जाने का फैसला किया और मैं आपकी समस्या को हल करने की कोशिश करने के लिए अजगर (अजगर-बाधा) उठाता हूं।

जानकारी

• 6 सत्र हैं
• 4 भूमिकाएँ हैं
• 6 अभ्यास हैं
• 32 छात्र हैं
• प्रति टीम 4 छात्र हैं

मुसीबत :

प्रत्येक छात्र को 4 भूमिकाओं में, 4 अभ्यासों में, 4 अलग-अलग सत्रों में असाइन करें।

अड़चनें:

1. छात्रों को एक बार एक भूमिका करनी चाहिए
2. छात्रों को 6 में से 4 अलग-अलग अभ्यास करना चाहिए
3. छात्रों को प्रति सत्र केवल एक अभ्यास करना चाहिए
4. विद्यार्थी को एक ही साथी से एक बार मिलना चाहिए

टेम्प्लेट:

यहां वह टेम्प्लेट है जो मैं छात्रों के साथ महसूस करता हूं, जहां प्रत्येक टीम 4 छात्रों से बना है, स्थिति [0, 1, 2 या 3] उन्हें सौंपी गई भूमिकाएं हैं। प्रत्येक उपलब्ध स्थिति 1 से 128 तक की संख्या है

[# Semester
   [ # Session
     [ # Practice/Team
1, 2, 3, 4],
  [5, 6, 7, 8],
  [9, 10, 11, 12],
  [13, 14, 15, 16],
  [17, 18, 19, 20],
  [21, 22, 23, 24]],
 [[25, 26, 27, 28],
  [29, 30, 31, 32],
  [33, 34, 35, 36],
  [37, 38, 39, 40],
  [41, 42, 43, 44],
  [45, 46, 47, 48]],
 [[49, 50, 51, 52],
  [53, 54, 55, 56],
  [57, 58, 59, 60],
  [61, 62, 63, 64],
  [65, 66, 67, 68],
  [69, 70, 71, 72]],
 [[73, 74, 75, 76],
  [77, 78, 79, 80],
  [81, 82, 83, 84],
  [85, 86, 87, 88],
  [89, 90, 91, 92],
  [93, 94, 95, 96]],
 [[97, 98, 99, 100],
  [101, 102, 103, 104],
  [105, 106, 107, 108],
  [109, 110, 111, 112]],
 [[113, 114, 115, 116],
  [117, 118, 119, 120],
  [121, 122, 123, 124],
  [125, 126, 127, 128]]]

दूसरे शब्दों में :

यह एक सत्र है:

 [[1, 2, 3, 4],
  [5, 6, 7, 8],
  [9, 10, 11, 12],
  [13, 14, 15, 16],
  [17, 18, 19, 20],
  [21, 22, 23, 24]],

वे टीम एक ही अभ्यास करते हैं:

[
    [1, 2, 3, 4],
    [25, 26, 27, 28],
    [49, 50, 51, 52],
    [73, 74, 75, 76],
    [97, 98, 99, 100],
    [113, 114, 115, 116]
]

वे एक ही भूमिका करते हैं:

[
   1,
   5,
   9,
   13,
   17,
   21,
   25,
   ...
]

मेरे पास अब तक क्या है:

अजगर-बाधा का उपयोग करके मैं पहले तीन बाधाओं को मान्य करने में सक्षम था:

Valid solution : False
            - sessions  : [True, True, True, True, True, True]
            - practices : [True, True, True, True, True, True]
            - roles     : [True, True, True, True]
            - teams     : [False, False, True, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, True, False, False, False, False, False]

उन लोगों के लिए जो दिलचस्प हो सकते हैं मैं बस इस तरह से करता हूं:

प्रत्येक शर्त के लिए मैं AllDifferentConstraint का उपयोग करता हूं । उदाहरण के लिए, एक सत्र के लिए:

problem.addConstraint(AllDifferentConstraint(), [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24])

मैं टीम में बाधा का रास्ता नहीं ढूंढ पा रहा हूं, semesterइस पूरे प्रयास का मेरा आखिरी प्रयास था:

    def team_constraint(self, *semester):
        students = defaultdict(list)

        # get back each teams based on the format [# Semester [ #Session [# Practice/Team ... 
        teams = [list(semester[i:i+4]) for i in range(0, len(semester), 4)]

        # Update Students dict with all mate they work with
        for team in teams:
            for student in team:
                students[student] += [s for s in team if s != student]

        # Compute for each student if they meet someone more than once 
        dupli = []
        for student, mate in students.items():
            dupli.append(len(mate) - len(set(mate)))

        # Loosly constraint, if a student meet somone 0 or one time it's find
        if max(dupli) >= 2:
            print("Mate encounter more than one time", dupli, min(dupli) ,max(dupli))
            return False
        pprint(students)
        return True

प्रशन :

1. क्या यह संभव है कि मैं टीम की परिस्थितियों के लिए क्या चाहता हूं? मेरा मतलब है कि मेरे पास कोई विचार नहीं है यदि प्रत्येक छात्र को 12 साथी सौंपना संभव है और उनमें से प्रत्येक एक ही साथी से केवल एक बार मिलते हैं।
2. टीम की बाधा के लिए, क्या मुझे अधिक प्रदर्शन करने वाले एल्गोरिथ्म की याद आती है?
3. कोई भी पिस्ट जो मैं फॉलो कर सकता हूं?

Comments

सत्रों के अंतिम दो सेट दूसरों (4, 4)की (4, 6)तरह आकार के क्यों हैं ?

— 20

यह इस तथ्य से मेल खाता है कि यह पाठ्यक्रम केवल एक क्रेडिट है और इसमें बहुत अधिक नौकरी की आवश्यकता होती है, इसलिए मेरे बॉस का मानना ​​है कि छात्रों को केवल 4 अभ्यास करना चाहिए। इसलिए हम इसके साथ आए, हमारे पास 32 छात्र हैं, जिन्हें 4 अभ्यास (128 पद) करने चाहिए।

— फ्लोरियन बर्नार्ड

मैं यादृच्छिक और जानवर बल दृष्टिकोण की कोशिश करेंगे। बस एक क्रमपरिवर्तन की तरह है जहाँ आप सत्र 1: भूमिका 1 छात्र 1 अभ्यास 1 ... 2 से 4 के साथ एक ही करते हैं। फिर प्रत्येक 6 सत्रों के लिए वेतन वृद्धि, पहले से मिले छात्रों को छोड़ दें। यादृच्छिक के साथ भी। 128 क्रमांक और प्रति सत्र 32 छात्रों के लिए अलग-अलग क्रमांक में अधिकतम के रूप में उपयोग क्यों नहीं? स्टैकमैथ में शायद वे आपको बता सकते हैं कि क्या यह संभव संयोजन / क्रमपरिवर्तन है

— क्रिस्टो

वर्तमान में ब्रूट फोर्स मेथड का काम, मेरा बॉस अपनी स्क्रिप्ट और अपने काम के साथ वास्तव में मेरे पास वापस आया। लेकिन मैं अभी भी टी अजगर का उपयोग करना चाहता हूं।

— फ्लोरियन बर्नार्ड

Answer 1

मुख्य प्रश्न का उत्तर कुछ इस तरह दिया जाएगा ...

   def person_works_with_different():
        # over all the sessions, each person works with each other person no more than once.
        # 'works with' means in 'same session team'
        for p in all_people:
            buddy_constraint = []
            for s in all_sessions:
                for g in all_teams:
                    p_list = [pv[k] for k in filter(lambda i: i[P] == p and i[S] == s and i[G] == g, pv)]
                    for o in all_people:
                        if o != p:  # other is not person
                            o_list = [self.pv[k] for k in filter(lambda i: i[self.P] == o and i[self.S] == s and i[self.G] == g, self.pv)]
                            tmp = model.NewBoolVar('')
                            buddy_constraint.append(tmp)
                            model.Add(sum(o_list) == sum(p_list)).OnlyEnforceIf(tmp)
                            # tmp is set only if o and p are in the same session/team
            # The number of times a student gets to take part is the number of roles.
            # The size of the group controlled by the number of roles
            model.Add(sum(buddy_constraint) = all_roles * (all_roles - 1)) 

जोड़ा गया संपादित करें

मैंने कल आपकी समस्या पर एक और नज़र डाली - (माना कि लंबे समय तक नहीं, क्योंकि मेरे पास इस समय बहुत काम है), और ...

सबसे पहले, मैं देखता हूं कि आपकी 'टीम' इकाई, बहुत अधिक है जिसे मैंने 'एक्शन' इकाई कहा है, और पूर्वव्यापी में मुझे लगता है कि 'टीम' (या 'समूह') इसके लिए एक बेहतर शब्द था।

यदि आप अभी भी बाधाओं को पा रहे हैं, तो मेरा सुझाव है कि आप उन्हें तोड़ दें, और व्यक्तिगत रूप से उन पर काम करें - विशेष रूप से टीम / व्यक्ति / सत्र बाधाओं, भूमिका / कार्य बाधाओं के बाद।

/ जोड़ा गया

team: a gathering of 4 persons during a session
person (32): a participant of a team
session (6): time: eg, 8am -10am
role (4): what responsibility a person has in an action
task (6): type of action

A person does:
 0..1 action per session-group
 1 role per action
 1 task per action
 0..1 of each task
 1 of each role in an action
 4 persons in an action

A person meets each other person 0..1 times
An action requires exactly 4 people

मुझे हाल ही में इसी तरह की समस्या हुई थी, और अंत में ओआर-टूल्स का रुख किया। https://developers.google.com/optimization/cp/cp_solver

विशेष रूप से, नर्स शेड्यूलिंग समस्या पर एक नज़र डालें: https://developers.google.com/optimization/scheduling/employee_scheduling#nurse_scheduling

किसी भी तरह, समस्या बहुत जटिल नहीं है, इसलिए शायद एक सॉल्वर का उपयोग करना आपके लिए ओवरकिल होगा।

इसी तरह, इस तरह की समस्या के लिए नेस्टेड सूचियों के बजाय अपने चरों को पकड़ने के लिए टफ-की-टाके का उपयोग करना बेहतर हो सकता है:

{टीम, सत्र, व्यक्ति: बूलवर}

मुख्य कारण यह है कि आप फिर फ़िल्टर के माध्यम से बाधाओं को लागू कर सकते हैं, जो कि नेस्टेड सूची में हेरफेर करने की तुलना में बहुत आसान है, उदाहरण के लिए, व्यक्तियों / टीमों में एक बाधा लागू करने के लिए, आप कर सकते हैं (जहां व्यक्ति 2 इंडेक्स है और टीम इंडेक्स है) 0):

for p in all_persons:
    for t in all_teams:
        stuff = [b_vars[k] for k in filter(lambda i: i[2] == p and i[0] == t, b_vars)]
        model.Add(sum(stuff) == 4)  # persons per team == 4

Comments

धन्यवाद, लूप के लिए क्या आपका मतलब था p for p in all_people?

— फ्लोरियन बर्नार्ड

हाँ क्षमा करें! मैंने अपने मॉडल में मेरे नामों का 'अनुवाद' किया, लेकिन काम पर था इसलिए थोड़ा जल्दी था।

— कोंचोग

इसके अलावा, मेलिंग सूची वास्तव में OR- उपकरण पर सहायक है। यदि आपको अपनी समस्या के बारे में मॉडलिंग करने में सहायता की आवश्यकता है, तो वे आपको कोड उदाहरण के लिए इंगित करेंगे या आपको समूह / निर्भरता बाधाओं को सेट करने के तरीके के बारे में एक महान विचार देंगे

— कोंचोग

मुझे क्षमा करें, लेकिन आपका सिर हल करने के लिए मुश्किल है, स्वयं कहाँ से आते हैं? और पी, एस और जी चर क्या हैं? Pv क्या है? आपकी सहायता के लिए धन्यवाद।

— फ्लोरियन बर्नार्ड

Answer 2

बस एक क्रमचय एल्गोरिथ्म विचार, प्रत्येक पुनरावृत्ति के लिए प्रत्येक छात्रों में से एक पर या प्रत्येक सत्र में से एक पर ध्यान केंद्रित किया जा सकता है:

Session 1:
Roles
1,2,3,4
Students
1,2,3,4

(Note is 1st permutation 1234)

Sess 2 for student 1
Roles 1234
Students 5,1,7,6

यहां छात्र 2 सत्र 1 में छात्र 1 का स्थान लेता है और इस तरह से आगे बढ़ता है

Roles 1234
St 2,5,6,7 

छात्र 1 एस 3 आर 1234 सेंट 10,9,1,8 के साथ जारी रखें

S4
R 1234
St 11,12,13,1

अंत में आप छात्र 1 के लिए इंटरैक्शन को हटाते हैं, जैसे अगले पुनरावृत्ति के लिए क्रमपरिवर्तन पर आप वर्तमान को हटाते हैं।

यह रूबिक्स क्यूब की तरह है।

यदि आपको यह कोड मिलता है या इस एल्गो के साथ कुछ कोड पता है तो मुझे बताएं।

शायद itertools क्रमपरिवर्तन के साथ

सत्र> व्यवहारों की तुलना में मेरा मानना ​​है कि यह प्रासंगिक नहीं है। जब आप बाहर घूमने जाते हैं या रोटेशन के लिए अधिक कमरा लेते हैं तो बस कुछ पूल। हो सकता है कि 4 सत्रों = प्रथाओं के लिए पहली बार समस्या को सरल बनाया जा सके?