2015-02-20 10 views
7

मैं पाइथन में स्विस टूर्नामेंट सिस्टम पर काम कर रहा हूं और मैं एक इष्टतम जोड़ी एल्गोरिदम को समझने की कोशिश कर रहा हूं।
मेरी सबसे बड़ी समस्या यह है कि प्रत्येक एल्गोरिदम मैं कुछ अनुक्रमों में उत्पादित त्रुटि के साथ आया था, जहां आखिरी जोड़ी को चुनने के लिए पहले से ही एक-दूसरे को खेला गया है, यह तय करना कि युग्मन अमान्य है।स्विस टूर्नामेंट - जोड़ी एल्गोरिदम

जिस स्विस सिस्टम पर मैं काम कर रहा हूं वह सरल है: यहां तक ​​कि खिलाड़ी, प्रत्येक दौर में हर कोई खेलता है और जोड़ी जीतने की निकटता के आधार पर किया जाता है (इसलिए मजबूत खिलाड़ी मजबूत खिलाड़ियों के खिलाफ खेलते हैं, और कमज़ोर के खिलाफ कमजोर होते हैं)।
कोई अलविदा, केवल जीत/हार (कोई ड्रॉ नहीं), विरोधी एक दूसरे को दो बार नहीं खेल सकते हैं।

वर्तमान एल्गोरिथ्म मैं इस प्रकार काम करता है क्या किया:

  1. क्रम रैंकिंग से एक खिलाड़ियों की सूची का उत्पादन (कम से कम करने के लिए जीत में सर्वाधिक जीत हासिल)
  2. पिक खिलाड़ी, सबसे जीत के साथ खिलाड़ी से शुरू
  3. मैच उसे निकटतम रैंकिंग खिलाड़ी के साथ। अगर वे पहले से ही खेला जाता है, ऐसे ही किसी के साथ उसे मेल खाते हैं जब तक कोई मिलान पाया जाता

को सूची से बाहर जोड़ी पॉप और वापस उदाहरण के लिए:
रैंकिंग 2 के बाद दौर:

1. P1: [P2 win, P3 win] 2 wins 
2. P5: [P6 win, P2 win] 2 wins 
3. P3: [P4 win, P1 lost] 1 win, 1 loss 
4. P4: [P6 win, P3 lost] 1 win, 1 loss 
5. P2: [P1 lost, P5 lost] 2 losses 
6. P6: [P5 lost, P4 lost] 2 losses 

पहला चयन पी 1 होगा और पहला मैच पी 5 होगा। सूची में से बाहर लेना (पी 1, पी 5)।

1. P3: [P4 win, P1 lost] 1 win, 1 loss 
2. P4: [P6 win, P3 lost] 1 win, 1 loss 
3. P2: [P1 lost, P5 lost] 2 losses 
4. P6: [P5 lost, P4 lost] 2 losses 

पहला चयन पी 3 होगा, पहले ही पी 4 खेला जाएगा, इसलिए मैच पी 2 होगा। सूची में से बाहर लेना (पी 3, पी 2)।
इस क्रम मैं एक जोड़ी है कि एक दूसरे को और जोड़ी के खिलाफ खेले साथ खत्म में अमान्य है:

1. P4: [P6 win, P3 lost] 1 win, 1 loss 
2. P6: [P5 lost, P4 lost] 2 losses 

प्रश्न: क्या कोई एल्गोरिथ्म एक इष्टतम जोड़ी मॉड्यूल की गारंटी देता है कि जब तक बना रही है यकीन है कि मैं नहीं मिलता है एक दूसरे को खेलने वाले दो खिलाड़ियों के साथ अंत में 'अटक गया'?

+0

इसे वजन के किनारों के साथ न्यूनतम लागत वाली अधिकतम मिलान समस्या के रूप में मॉडलिंग किया जा सकता है। जीत (ए) - जीत (बी) | प्रत्येक जोड़ी {ए, बी} टीमों के लिए जो अभी तक एक-दूसरे के खिलाफ नहीं खेले हैं। यह सुनिश्चित नहीं है कि इसे कैसे हल किया जाए। –

+1

वास्तव में, एक [बहुपद समय समाधान] (http://mpc.zib.de/index.php/MPC/article/viewFile/11/4) –

+0

@NiklasB प्रतीत होता है। सामान्य मिलान हमें एक दौर में फंसने से रोकता है, लेकिन मुझे लगता है कि वैध राउंड चुनना संभव है जो सामान्य मिलान वाले डी-नियमित ग्राफ को छोड़ दें। –

उत्तर

3

एक जानवर बल एल्गोरिथ्म, एक इष्टतम जोड़ी मॉड्यूल को खोजने के लिए गारंटी दी जा होगा अगर वहाँ एक है: एक जोड़ी (शायद बनती खिलाड़ियों की जीत के अंतर)

  • आधार के लिए

    1. परिभाषित दंड समारोह इस पर, मॉड्यूल को जोड़ना (शायद मॉड्यूल में जोड़ों के संबंधित जुर्माना मूल्यों के वर्गों का योग)
    2. सभी मान्य मॉड्यूल का आकलन करें (ध्यान दें कि कोई भी नहीं हो सकता है)
    3. प्रत्येक मान्य मॉड्यूल के लिए मॉड्यूल पी की गणना करें (2.)
    4. इस मान से क्रमबद्ध करें और सबसे छोटे पेनल्टी मूल्य के साथ (एक) मॉड्यूल (ओं) का चयन करें। (न्यूनतम कई लोगों द्वारा साझा किया जा सकता है।)

    खिलाड़ियों की एक छोटी संख्या के लिए, यह संभवतः व्यवहार्य रनटाइम भी हो सकता है। बड़ी संख्या के लिए, आप अनुकूलन और शॉर्टकट देखना चाहते हैं।

  • 2

    शायद मैं इसके साथ आपकी मदद कर सकता हूं। शतरंज में हमारे पास अलग स्विस जोड़ी एल्गोरिदम हैं लेकिन वे सभी एक मजबूत-कमजोर जोड़ी के साथ काम करते हैं (आश्चर्य हो सकता है)।

    डच एक (सबसे अधिक उपयोग किया जाने वाला) का मूल सिद्धांत यह है कि, एक बार जब आप अपनी जोड़ी संख्या सौंप चुके हैं, तो आप प्रत्येक स्कोर ब्रैकेट के लिए एल्गोरिदम लागू करते हैं।

    एल्गोरिथ्म मोटे तौर पर काम करता है:

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

    अगले स्कोर में ब्रैकेट: यदि फ़्लोटर्स हैं, तो उन्हें पहले जोड़े। फिर, अवशिष्ट समूह के साथ पहले की तरह ही वही करें।

    कुछ और नियम यह सुनिश्चित करने के लिए जोड़े गए हैं कि कम से कम एक जोड़ी संभव है।

    उदाहरण के लिए: यदि कोई एक्सचेंज पर्याप्त पर्याप्त जोड़ी बनाने में सक्षम नहीं है, तो पिछले स्कोर ब्रैकेट पर बैकट्रैक और फ़्लोटर्स बनाने के लिए जोड़ी को तोड़ दें।

    यह डच युग्मन प्रणाली का वास्तव में एक मोटा स्पष्टीकरण है, लेकिन यह आपके प्रश्न पर जाने वाला है।

    0

    मेरे पास कुछ समय पहले एक ही प्रश्न था और पाइथन में न्यूनतम वजन अधिकतम मिलान एल्गोरिदम का उपयोग करके समाधान तैयार करना समाप्त हो गया। इसके लिए एक अच्छी पुस्तकालय भी है! https://healthyalgorithms.com/2009/03/23/aco-in-python-minimum-weight-perfect-matchings-aka-matching-algorithms-and-reproductive-health-part-4/

    मैंने ब्लॉग पोस्ट में अपनी विचार प्रक्रिया लिखी और इसे बनाने के दौरान उपयोग किए जाने वाले संसाधनों से लिंक करना सुनिश्चित किया। उम्मीद है कि यह सहायक है: https://www.leaguevine.com/blog/18/swiss-tournament-scheduling-leaguevines-new-algorithm/

    1

    मुझे एक ही समस्या थी और इसे निम्न तरीके से हल किया गया। एक:

    1. मैं दो समूहों
    2. प्रत्येक समूह के लिए में बीच में रैंकिंग अलग किया है। पंक्तियों और कॉलम बी में खिलाड़ियों के साथ एक मैट्रिक्स बनाएं। वर्जित जोड़े के लिए एक उच्च लागत (उदाहरण: 10000) असाइन करें (उदाहरण: पहले से खेले गए, खिलाड़ियों की विषम संख्या के मामले में डमी प्लेयर) सी। अन्य सभी जोड़े के लिए "प्रदर्शन" मान असाइन करें, उदाहरण के लिए अंक अर्जित करने और डी खोने वाले अंकों की संख्या के आधार पर। सभी संभावित मैचों को ढूंढें, केवल मैट्रिक्स के आधे हिस्से में क्योंकि यह एक दर्पण है। इस समाधान के "प्रदर्शन मूल्य" को ई प्राप्त करें। लागत के साथ जोड़े छोड़ें> 10000 एफ। समाधानों की सूची को क्रमबद्ध करें, सबसे कम योग प्रविष्टि

    3. यदि कोई समाधान नहीं है, तो खिलाड़ियों को विभाजित किए बिना उसी एल्गोरिदम को फिर से करें।

    हमेशा एक इष्टतम समाधान होता है यदि मोड़ों की संख्या नियंत्रित होती है। उदाहरण के लिए, 20 खिलाड़ियों के लिए, राउंड की इष्टतम संख्या 5 है, और अधिक खतरनाक हो सकती है (कोई समाधान नहीं मिला है)।

    मैंने सी ++ में इस एल्गोरिदम को कार्यान्वित किया है और वास्तविक टूर्नामेंट के लिए क्षेत्र में परीक्षण किया है, यह बहुत अच्छा काम करता है।आप इसे "टूर्नामेंट.cpp" नामक फ़ाइल में Tanca repository में गिथब पर पा सकते हैं।

    मैंने अपने ब्लॉग (फ्रेंच में, क्षमा करें) पर एक लेख भी लिखा है।

    संबंधित मुद्दे