👩🏿‍🤝‍👨🏾 ⛹️ 🎹 Wirth और जंजीरों के सवाल के लिए 🏉 🧔 🎴

एल्गोरिदम + डेटा संरचनाएं = कार्यक्रम - पुण्य एन।

"हमारे पास एक छोटा लेकिन अत्यंत शिक्षाप्रद सामरिक अभ्यास करने का शानदार अवसर था"

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

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

सबसे पहले, हम निर्धारित करते हैं कि खेल परिमित है, क्योंकि प्रत्येक कदम के साथ वस्तुओं की संख्या सख्ती से घट जाती है और खेल समाप्त हो जाता है जब शून्य द्वारा गणना की गई वस्तुओं की संख्या तक पहुंच जाती है, इसलिए हमें इस खेल के अध्ययन में सफलता पर भरोसा करने का अधिकार है। इसके अलावा, यह स्पष्ट है कि खेल एन चाल से अधिक नहीं चल सकता है, हमें इस तथ्य को याद रखना चाहिए।

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

एच के कुछ के लिए, उत्तर स्पष्ट है - एक वस्तु के साथ, पहला एक बारी में एक सीधा गेम जीतता है और एक उलटा गेम भी खो देता है (P1 = 1, I1 = -1)। दो वस्तुओं के साथ, पहला खिलाड़ी एक प्रत्यक्ष गेम में दो चालों में हार जाता है और उलटा (पी 2 = -2, आई 2 = 2) में दो चालों में जीतता है, जो इस खेल का मूल्यांकन करने की सादगी के बारे में एक परिकल्पना को जन्म दे सकता है, जिसकी पुष्टि तीन वस्तुओं (पी 2 = 3) के मामले में की जाती है। I3 = -3)। सौभाग्य से (अन्यथा यह पोस्ट प्रकाशित नहीं हुई होगी) चार वस्तुओं के साथ एक गेम तस्वीर को कुछ हद तक बदल देता है (पी 4 = -4, लेकिन I4 = -3), इसलिए खेल पर शोध करना वास्तव में आवश्यक है।

कुछ एच के लिए और एक निश्चित प्रकार के गेम के लिए, हेयोरिस्टिक एल्गोरिदम हैं जो गारंटीकृत अदायगी देते हैं। उदाहरण के लिए, एक विषम प्रारंभिक एच के साथ सीधे गेम के लिए, आपको जीतने की गारंटी दी जा सकती है यदि आप पहली चाल के साथ केंद्रीय ऑब्जेक्ट को हटाते हैं और फिर सममिति के अक्ष के रूप में केंद्रीय स्थान का उपयोग करके प्रतिद्वंद्वी के चाल को दोहराते हैं, तो हमें अंतिम ऑब्जेक्ट लेने और जीतने की गारंटी है। एक ही रणनीति वस्तुओं की एक समान संख्या के साथ काम करेगी, यदि पहली चाल पर प्रतिबंध के लिए नहीं, जो खेल को इतना तुच्छ नहीं बनाता है। सामान्यतया, सममित रणनीति का उपयोग गिनती के खेल में काफी सामान्य घटना है, लेकिन रामबाण नहीं है, क्योंकि, उदाहरण के लिए, हमारे उलटा खेल में यह रणनीति विफल हो जाती है। यह ध्यान दिया जाना चाहिए कि हेयूरिस्टिक्स एक जीतने वाला एल्गोरिदम देते हैं, लेकिन स्थिति का सटीक अनुमान नहीं देते हैं, क्योंकि ऐसी रणनीतियां हो सकती हैं जो तेजी से जीत की ओर ले जाती हैं (यह इस विशेष गेम के लिए मामला है)।

हम खेल का मूल्यांकन कैसे कर सकते हैं - जैसा कि मैंने 1-4 वस्तुओं के लिए पिछले अनुमान प्राप्त किया था - विधि को ऊपर से नीचे तक संपूर्ण खोज कहा जाता है - हमें पूर्ण गेम ट्री पर विचार करने की आवश्यकता है, अर्थात दोनों पक्षों पर सभी संभावित चालें और प्रत्येक स्थिति का मूल्यांकन करें, जिसमें शामिल हैं स्रोत, कुछ नियमों के अनुसार। यह ध्यान दिया जाना चाहिए कि सफल उत्तराधिकार का अस्तित्व हमें एक सटीक मूल्यांकन की गारंटी नहीं देता है, क्योंकि यह सवाल के केवल पहले आधे हिस्से का जवाब देता है - जो जीतता है, लेकिन न्यूनतम आवश्यक संख्या में चाल नहीं देता है।

इसका मतलब यह है कि हमें एक पूर्ण गेम ट्री का निर्माण करना चाहिए, लेकिन निर्माण के साथ आगे बढ़ने से पहले, हमें अध्ययन के तहत वस्तु का एक मॉडल बनाना होगा, हमारे मामले में, खेल।

मैं इस चरण पर ध्यान केंद्रित क्यों करता हूं - क्योंकि हम इसके भौतिक अवतार में वस्तु का पता नहीं लगा सकते हैं। नहीं, विशुद्ध रूप से सैद्धांतिक रूप से यह संभव है ("सामान्य रूप से विशुद्ध रूप से दुनिया में थोड़ा संभव है") और मैं काफी हद तक एक तस्वीर की कल्पना कर सकता हूं, जहां बहुत बड़ी संख्या में रोबोट वास्तविक दुनिया में बहुत सारे गेम खेलते हैं, लेकिन खेल के मूल्यांकन की समस्या के समाधान के लिए सामग्री की लागत तर्कसंगत रूप से बहुत अधिक है। मात्रा, इसलिए हम वास्तविक वस्तुओं को उनके सॉफ्टवेयर समकक्षों के साथ मॉडलिंग करने के लिए मजबूर कर रहे हैं। और यहां एक पर्याप्त रेखा के साथ मॉडल पर्याप्तता और आवश्यक सरलीकरण के संयोजन के साथ जाना बहुत महत्वपूर्ण है।

लेकिन सबसे पहले, कार्य की जटिलता का आकलन करने के लिए थोड़ा गणित - हमें खेल में सभी संभावित चालों के माध्यम से क्रमबद्ध करने की आवश्यकता है (ध्यान सभी संभव पदों नहीं है, यह एक अन्य विधि का विषय है, अर्थात् चालें) और हम काम शुरू करने से पहले संसाधनों की आवश्यक मात्रा का मूल्यांकन करना चाहेंगे - कार्य के क्रम को निर्धारित करने के लिए। पहले कदम पर, हमारे पास H से उपलब्ध किसी भी चिप (मैं वस्तुओं को कॉल करना जारी रखूंगा) को हटाने का अवसर है, अगले कदम पर - शेष एच -1 या दो में से कोई भी चिप पास में पड़ी है (एच -2 की तुलना में ऐसी जोड़ी से अधिक नहीं होगा), जो विकल्पों की कुल संख्या Hx (H-1 + H-2) देता है। यह देखना आसान है कि तीसरी चाल के बाद हमारे पास Hx (H-1 + H-2) x (H-2 + H-3 + that) और इतने पर है।

यदि हम प्रत्येक ब्रैकेट में खुद को केवल योग की पहली शर्तों तक सीमित रखते हैं, तो हमें एच के रूप में कुल चालों की संख्या का अनुमान मिलता है, जो हमें एच ^ एच के चतुर्भुज में एक अनुमान देता है!

यह एक बहुत ही अप्रिय परिणाम है, जो दावा करता है कि हमें महत्वपूर्ण एच के साथ बहुत बड़ी समस्याएं होंगी, जिससे कि सबसे अधिक "हेड-ऑन" मॉडलिंग महत्वपूर्ण कम्प्यूटेशनल लागतों को पूरा करेगा। उदाहरण के लिए, शुरुआती स्थिति में 16 चिप्स के लिए, हमें लगभग 16! = 10 moves13 चालों पर विचार करने की आवश्यकता होगी, और यदि एक चाल 10E-9 सेकंड (बहुत आशावादी अनुमान) है, तो कुल समय लगभग 10E4 सेकंड या लगभग 3 घंटे होगा, जो थोड़ा अधिक है , लेकिन स्वीकार्य है, लेकिन सिर्फ 20 चिप्स के लिए, अपेक्षित गणना समय 77 वर्ष है, जो स्पष्ट रूप से अस्वीकार्य है। फैक्टरियल बहुत तेजी से बढ़ रहा है और इसके बारे में कुछ भी नहीं किया जाना है।

हम इस तथ्य पर ध्यान आकर्षित करते हैं कि चालों की संख्या संभावित पदों की संख्या से अधिक है, जो केवल 2 ^ N है, और यह स्पष्ट है कि हम 16 चिप्स 10E (13-5) = 10E7 बार के लिए एक अलग स्थिति में आ जाएंगे, जो कि हर रोज होने वाली घटना है खोज कार्य। इस तथ्य को याद रखें, यह बाद में हमारे लिए उपयोगी होगा।

फिर भी, हम एक कार्यक्रम लिखना शुरू करेंगे, जिसके लिए हम मॉडल का निर्धारण करेंगे। सबसे पहले, हम चिप्स को 1 से एच तक संख्या देते हैं, फिर तत्वों की संख्या एच के साथ एक सरणी बनाते हैं, और यह निर्धारित करते हैं कि सूचकांक एन के साथ सरणी तत्व में नंबर 1 का मतलब है चिप नंबर n की उपस्थिति, और नंबर 0 - एक विशिष्ट स्थिति में इसकी अनुपस्थिति। ऐसा मॉडल पर्याप्त, सरल, सहज ज्ञान युक्त है, और आपको चिप हटाने के संचालन को प्रभावी बनाने की अनुमति देता है, साथ ही साथ "निकटता" की स्थिति का निर्धारण भी करता है।

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

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

तटस्थ मूल्यांकन में परिवर्तन होता है,
एक सकारात्मक रेटिंग एक छोटे से सकारात्मक में बदलती है,
एक नकारात्मक मूल्यांकन एक बड़े नकारात्मक या सकारात्मक में बदलता है।

हम पूरी तरह से सभी चालों से गुजरने के बाद, प्रारंभिक स्थिति का आकलन अंतिम है।

हम सभी पदों को सृजित करने के लिए अपनी प्रक्रिया में अनुमान जोड़ते हैं और हम विश्लेषण के परिणामों की प्रशंसा कर सकते हैं, जो तालिका में प्रदर्शित किए गए हैं, विश्लेषण के लिए एक प्रगति काउंटर और एक समय मीटर जोड़ें। एक प्रोसेसर के साथ एक मशीन पर gcc कंपाइलर (ऑप्टिमाइज़ेशन मोड -O2) में, मुझे ऐसी तालिका मिली जो कार्य की जटिलता के तथ्यात्मक क्रम के बारे में हमारी प्रारंभिक धारणाओं की पूरी तरह से पुष्टि करती है। उसी तालिका से, हम देखते हैं कि मैंने 11 से अधिक एच के साथ परिणामों की अपेक्षा करना बंद कर दिया है, क्योंकि गणना का समय अस्वीकार्य हो गया (मेरे लिए, शायद आप आधे घंटे इंतजार करने के लिए तैयार हैं) और पाठ्यक्रम के बारे में हमारी धारणा और नैनोसेकंड वास्तविकता के अनुरूप नहीं है (औसत समय) स्थिति का विचार 100 nsec है)। सवाल उठता है - यदि हम प्रारंभिक स्थिति में 11 से अधिक चिप्स के लिए अनुमान लगाना चाहते हैं तो हमें क्या करना चाहिए।

हम छोटे अनुकूलन का रास्ता अपना सकते हैं, संक्रमण और झंडे के साथ खेल सकते हैं, असेंबलर आवेषण में जा सकते हैं, हमारे प्रोसेसर के निर्देशों की प्रणाली से मुश्किल वेक्टर ऑपरेशन लागू कर सकते हैं, और इस तरह आप कई बार गति से एक क्रम से गति से जीत सकते हैं - शायद परिमाण के दो आदेश - यह बहुत संभावना नहीं है, लेकिन हमें परिमाण के कई आदेशों के लाभ की आवश्यकता है, चूंकि ऑर्डर (और भी अधिक) हम एच में वृद्धि को एक से अधिक 10 खाएंगे। वैसे, यदि आप बस कंपाइलर अनुकूलन को चालू करते हैं, तो यह हमारे लिए कुछ करेगा और निष्पादन समय घट जाएगा सब पर और हमारी उम्मीदों के साथ लाइन में बुरा नहीं - मैं 4 बार की है।

इसलिए, हमें पहले लागू एल्गोरिदम में सुधार करने की कोशिश करनी चाहिए, और इनमें से पहला (और मुख्य) सुधार कट-ऑफ ब्रूट फोर्स विधि या "अल्फा-बीटा प्रक्रिया" है। इसका मुख्य विचार काफी मजबूत दिखता है और इस तथ्य में शामिल है कि यदि हम एक जीतने वाले के रूप में एक निश्चित स्थिति का मूल्यांकन करते हैं, तो हम इस एक के लिए रेटिंग में सुधार करना बंद कर देते हैं और वापस पेड़ पर लौट आते हैं। यह दृष्टिकोण एल्गोरिथम की गति को बहुत बढ़ा सकता है, खासकर अगर हम पहली बार में सफल चाल (एक जीत के लिए अग्रणी) की जांच करते हैं। लेकिन यह समय भी बढ़ा सकता है, चूंकि वर्तमान मूल्यांकन का सत्यापन जोड़ा जाता है और पाठ्यक्रम को चुनने की प्रक्रिया जटिल है, इसलिए इस पद्धति के प्रभाव का पहले से अनुमान लगाना बहुत मुश्किल है, एक प्रयोग करना आवश्यक है। और एक और विचार - हमें यह नहीं भूलना चाहिए कि एक कट-ऑफ के साथ खोज के मामले में, एक जीतने की स्थिति के मामले में, हम एक सही, लेकिन सटीक अनुमान नहीं देते हैं, क्योंकि हम विकल्पों का हिस्सा नहीं मानते हैं, और वे कम चालों में जीत दे सकते हैं। यदि सटीकता में इतनी कमी हमें सूट करती है, तो इस पद्धति का उपयोग क्यों न करें, लेकिन एक सटीक आकलन के लिए, संपूर्ण खोज के अलावा कुछ भी काम नहीं करता है।

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

हम इस तथ्य पर ध्यान दें कि हमारे द्वारा अपनाई गई डेटा संरचना चिप्स को अद्वितीय बनाती है और उदाहरण के लिए, स्थिति में एक एकल (आसन्न नहीं) चिप स्थिति n + 2 में एकल चिप के बराबर नहीं है, जो पूरी तरह से गलत है। हम खेल की स्थिति के प्रमुख तत्व का चयन करते हैं - इसके बगल में स्थित चिप्स का समूह और इसकी मुख्य विशेषता निर्धारित करता है - समूह में चिप्स की संख्या। यह इस जानकारी है कि विशिष्ट रूप से खेल में किसी भी स्थिति को निर्धारित करता है, और हमें इसे प्रोग्रामिंग के लिए सुविधाजनक रूप में प्रस्तुत करना चाहिए। हम सबसे सरल और सबसे स्पष्ट डेटा संरचना चुनते हैं - हम एच तत्वों की एक सरणी शुरू करते हैं और सरणी के एन तत्व में स्टोर करते हैं जिसमें बिल्कुल n चिप्स के साथ समूहों की संख्या होती है। फिर, उदाहरण के लिए। 3 चिप्स के साथ शुरुआती स्थिति के लिए, हमारे पास {0,0,1} प्रतिनिधित्व होगा। दी गई प्रस्तुति के लिए निष्पादन प्रक्रिया अभी भी सरल और प्रभावी है, हालांकि, निश्चित रूप से, पहले संस्करण की तुलना में अधिक जटिल है। पहली चाल के बाद (जिसमें तीन के बजाय दो थे) हम पदों को प्राप्त करते हैं {0,1,0} और {2,0,0}।

आइए किसी दिए गए डेटा संरचना के लिए चाल की संख्या में अपेक्षित लाभ का अनुमान लगाने का प्रयास करें। पहली चाल के लिए, हमारे पास (H-1) / 2 + 1 विकल्प हैं, दूसरे के लिए (हमने समूह H को m और N-m-1 में विभाजित किया) (m-1) / 2 + (N-m-1-1) / 2 (1 चिप लें) + (m-2) / 2 + (N-m-1-2) / 2 (2 चिप्स लें) = (H-3) / 2 + (H-5) / 2 और सादृश्य द्वारा , हम निष्कर्ष निकालते हैं कि हर कदम पर हम कम से कम आधी चालें बचाते हैं। तब हमारा लाभ कम से कम 2 ^ एच होना चाहिए, जो कि बहुत बड़ा एच के लिए बहुत अच्छा है। वास्तव में, लाभ और भी अधिक होगा, उदाहरण के लिए, पहले अवतार में स्थिति {8,0 ...} के लिए, आपको 8 चालों को छांटना होगा, और दूसरे में केवल 1 और इस मामले में लाभ 8 गुना होगा। इसलिए हम दृढ़ता से 2 ^ एच पर भरोसा कर सकते हैं, लेकिन बहुत अधिक उम्मीद करते हैं, जिसे हम जांचेंगे। और निश्चित रूप से, इस प्रतिनिधित्व के अनुसार कार्यक्रम के लिए, हमें तालिका 4 मिलती है, अंतिम पंक्ति डेटा संरचना (हाथों द्वारा गणना) के दूसरे संस्करण में स्विच करते समय प्रदर्शन लाभ दिखाती है। विकास केवल ठोस है और हम आत्मविश्वास से (नीचे तक पहुंच गए) एक उचित समय लागत पर शुरुआती स्थिति में 20 चिप्स तक के विश्लेषण की संभावना की छत के माध्यम से टूट गए।

इसके अलावा, हम किसी दिए गए डेटा संरचना के लिए एल्गोरिथ्म के सूक्ष्म अनुकूलन में संलग्न हो सकते हैं और प्रदर्शन में भी लाभ प्राप्त कर सकते हैं, लेकिन हमें ऐसा नाटकीय (परिमाण के आदेशों से) विकास नहीं मिलेगा, जो एक बार फिर इंगित करता है कि विर्थ गलत था। उदाहरण के लिए, उपरोक्त कार्यक्रम में, इस कदम के लिए अगले उम्मीदवार बनाने की प्रक्रिया जानबूझकर इष्टतम नहीं थी और इसके स्पष्ट सुधार (जिज्ञासु पाठक को छोड़ दें) की गति में 3 गुना वृद्धि होगी, लेकिन यह एक सुखद है, हालांकि यह एक सुखद है।

आइए परिणामों पर ध्यान दें और कुछ स्पष्ट चीजें न देखें। उदाहरण के लिए, कार्यक्रम का दावा है कि 9 चिप्स के लिए एक प्रत्यक्ष गेम में एक गारंटीकृत जीत 9 चालों में नहीं प्राप्त की जाती है, जैसा कि हेयुरिस्टिक सममित एल्गोरिथ्म से होता है, लेकिन केवल 7 में, और पहला कदम हेयुरिस्टिक (और, के साथ मेल खाता है), केवल जीतने की स्थिति है ), लेकिन तीसरे और बाद वाले को प्रतिद्वंद्वी के चाल को बिल्कुल भी नहीं दोहराना चाहिए, जैसा कि भोली एल्गोरिथ्म से होता है, और यहां कुंजी {1,0,0,1} है, जिसकी रेटिंग +4 है। अब जब हमने खेल का सटीक आकलन कर लिया है, तो हम स्थिर मूल्यांकन के साथ पदों की उपस्थिति के बारे में दिलचस्प सवाल पूछ सकते हैं (जिसमें हम प्रतिद्वंद्वी को खुद के लिए जाने दे सकते हैं), गणना वृक्ष में प्रमुख पदों की उपस्थिति, एकमात्र चाल से पदों की खोज, और इसी तरह (और) यहां तक कि इन सवालों के जवाब भी मिलते हैं, और सही)।

यहाँ सारांश ग्रेड तालिका है

चिप्स	सीधे	संपर्क	पद / समय	पद / समय
1	1	-1	1/0	1/0
2	-2	2	4/0	2/0
3	3	-3	17/0	7/0
4	-4	-3	82/0	20/0
5	5	4	463/0	71/0
6	5	-5	3032/0	263/0
7	7	6	22693/0	1107/0
8	-8	-7	191422/0	4945/0
9	7	-7	1798427 / 0.1	24,283 / 0
10	9	8	18634228 / 0.8	125419/0
11	11	-9	211177537 / 10.4	699165 / 0.1
12	-10	-9	* / १२ *	4057686 / 0.6
13	11	10		25056975 / 3.84
14	-12	-11		160643971/28
15	13	12		1082854607/213
16	-14	-13		*** / 1698

फिर भी, हम देखते हैं कि विकास दर में उल्लेखनीय कमी के साथ परिचालन समय का अनुमान तथ्यात्मक बना हुआ है। आइए खेल के पेड़ का पता लगाने के अन्य तरीकों की तलाश करें।

हमने टॉप-डाउन एल्गोरिथ्म को पूरा किया है (ठीक है, निश्चित रूप से, हमने इसे बदसूरत रूप में समाप्त नहीं किया है कि मैंने लिफाफे के पीछे स्केच किया है, आप बुनियादी प्रक्रियाओं को ध्यान से लिखकर प्रदर्शन में काफी सुधार कर सकते हैं, और यह निश्चित है, लेकिन समस्या मूल रूप से नहीं है फैसला करता है), तो चलें दूसरे तरीके से - नीचे से ऊपर तक। इस पद्धति का विचार सहज रूप से सरल और समझने योग्य है, लेकिन मानव उपयोग के लिए बहुत मुश्किल है - हम अंतिम स्थिति से शुरू करते हैं, जो कि खेल के नियमों के अनुसार अनुमानित है, और शीर्ष-डाउन खोज के लिए उसी नियमों के अनुसार पेड़ को अनुमान हस्तांतरित करना शुरू करते हैं। बेशक, एक ही समय में हम वर्तमान स्थिति से संभव कदमों पर विचार नहीं कर रहे हैं, लेकिन हम उन सभी पदों पर विचार कर रहे हैं, जिनसे हम एक चाल में वर्तमान में पहुंच सकते हैं। हम उपरोक्त नियमों के अनुसार अनुमान को स्थानांतरित करते हैं। इसके अलावा, हम इस प्रक्रिया को चलने के लिए लागू करते हैं और जब यह परिणामों का उत्पादन करना बंद कर देता है, यानी अगले दौर में, एक भी स्थिति ने मूल्यांकन नहीं बदला, कार्य पूरा हो गया है और प्रारंभिक स्थिति का आकलन सही और सटीक है। यह दृष्टिकोण आपको खोज समय को बहुत कम करने की अनुमति देता है, खासकर यदि आप कुछ सुधार करते हैं, लेकिन इसकी एक मजबूत खामी है (और यह एक क्लासिक है - हम स्मृति के लिए समय बदलते हैं), इसके दायरे को सीमित करते हुए - उच्च स्मृति आवश्यकताओं, क्योंकि हमें अनुमानों को संग्रहित करना चाहिए , ( ).प्रश्न में खेल के मामले में, पहले डेटा संरचना के लिए बिट-प्रतिनिधित्व विधि स्वयं का सुझाव देती है, ऐसी अन्य विधियां हैं जो आवश्यक मेमोरी की मात्रा को कम कर सकती हैं (निचली परत के अपवाद के साथ केवल तीन माना पेड़ के स्तर को संग्रहीत करते हुए), लेकिन, ज़ाहिर है, प्रदर्शन को नीचा करके, क्योंकि खोज बहुत गैर-तुच्छ हो जाती है। फिर भी, एच 20 से अधिक नहीं के लिए, कुल पदों की संख्या 2 ^ 20 से अधिक नहीं होगी, और -20 से 20 की संख्या वाले तत्वों के लिए स्मृति में इस आकार की एक सरणी, अर्थात, 8-बिट संख्या, मैं कल्पना करने में काफी सक्षम हूं और इसका कार्यान्वयन मुश्किल नहीं होगा। इसलिए इस तरह के एक एल्गोरिथ्म के लिए एक कार्यक्रम लिखना और परिणामी प्रदर्शन का मूल्यांकन करना संभव है, लेकिन चलो जल्दबाजी न करें और अनुमान न लगाएं। हमें किस प्रकार की मेमोरी आवंटित करनी होगी, यह निर्धारित करना मुश्किल नहीं है, लेकिन अस्थायी मापदंडों के साथ यह कुछ अधिक जटिल है।मान लीजिए कि हम तुरंत सभी संभावित पदों का सृजन करते हैं, वे एम होंगे, फिर एक स्थिति से औसत चालों की संख्या 2 * एन (एक बहुत मोटा अनुमान) से अधिक नहीं हो सकती है। फिर, प्रत्येक पुनरावृत्ति पर, हमें अनुमान के M * 2 * N हस्तांतरण से अधिक नहीं करने की आवश्यकता है, और चूंकि प्रत्येक चक्र में हम कम से कम एक स्थिति के अनुमान में सुधार करेंगे, कुल परिचालन समय क्रम M * 2 * N * M का होगा।

फिर, डेटा को प्रस्तुत करने के पहले तरीके के लिए, हम 2 ^ H * M * 2 ^ H = 2 ^ (2 * H) * M प्राप्त करते हैं (हम एक बार फिर जोर देते हैं कि यह अनुमान ऊपर से बहुत मजबूत है) और, उदाहरण के लिए, H 20: ऊपर से खोज समय का अनुमान। -डाउन 20 होगा! ~ 10E18, और बॉटम-अप सर्च के लिए हमारे पास 2 ^ 40 * 20 = (2 ^ 10) ^ 4 * 40 = (10 ^ 3) ^ 4 * 40 ~ 10 ^ 14, यानी 20 चिप्स हम कम से कम 10E6 बार जीतते हैं, जो बहुत अच्छा है। हम 9 प्रारंभिक चिप्स के लिए भी गणना करेंगे, शीर्ष खोज के लिए 9! ~ 10E6 प्राप्त कर रहे हैं, और नीचे की स्क्रीनिंग के लिए 2 ^ 9 * 2 ^ 9 * 18 ~ 10E6, अर्थात्, इस संख्या से शुरू होकर, नीचे-पंक्ति खोज जीत जाती है। अंतिम कथन कुछ जल्दबाजी है, क्योंकि अगली स्थिति का मूल्यांकन करने की प्रक्रिया काफी लंबी हो गई है - हमें पहले से ही उत्पन्न लोगों के बीच इसकी तलाश करनी होगी, लेकिन बिट सरणी के रूप में इस विशेष प्रतिनिधित्व के लिए, यह प्रक्रिया O (1) में की जाती है।

दूसरी प्रस्तुति के लिए, विभिन्न पदों की संख्या का मूल्यांकन करना आवश्यक है, जो कि कॉम्बिनेटरिक्स के क्षेत्र से एक कार्य है। एक उदाहरण के रूप में, 9 प्रारंभिक चिप्स के साथ एक गेम पर विचार करें, जिसके लिए विभिन्न पदों की कुल संख्या होगी: 1+ (1 + 4) + (1 + 3 + 2) + (1 + 3 + 3 + 2) + (1 + 2 +) 2 + 1 + 1) + (1 + 2 + 1 + 1) + (1 + 1 + 1) + (1 + 1) + 1 = 1 + 5 + 6 + 9 + 7 + 5 + 3 + 2 + 1 = 39।
फिर उसी पद्धति से एक अनुमान H * M * M = 39 * 39 * 9 ~ 10E4 के मान को आगे बढ़ाएगा, जो कि पहले प्रतिनिधित्व की तुलना में गति में बेहतर परिमाण के दो आदेश हैं, और जैसे ही H बढ़ता है, लाभ केवल बढ़ेगा। दूसरे दृश्य के लिए ऊपर से खोज की तुलना में, किसी को प्रदर्शन में एक महत्वपूर्ण सुधार की उम्मीद करनी चाहिए, लेकिन इसका मूल्यांकन करना अधिक कठिन है, इसलिए कोशिश करना आसान है।

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

— , , . , , ( ) .

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

पुनश्च।वे मुझे यहां दर्शकों (हाय मैक्स) से कहते हैं कि खेल पर शोध करने का एक और तरीका है - गणितीय, और, डबल-उपनाम की परिकल्पना को देखते हुए कि ज्यादातर गिनती के खेल निम के खेल में आते हैं, इसलिए हमें केवल उसकी गणना करने की आवश्यकता है-योग प्रारंभिक स्थिति (मेरी राय में, कथन संदिग्ध है), और आप ग्राफ पर गेम को मूल गेम में भी बदल सकते हैं (कोई आपत्ति नहीं है), जिसके लिए आप काम के समय तक 1.878 ^ N के अनुमान की उम्मीद कर सकते हैं (हालांकि विशिष्ट संख्या कुछ हद तक मुझे हैरान कर देती है)। संभवतः, इन विचारों को जीवन का अधिकार है, कम से कम इस सामग्री के लेख आश्वस्त दिखते हैं, लेकिन मैं एक शुद्ध व्यवसायी हूं और जिज्ञासु पाठकों (आरएस लोंगा, वीटा ब्रेविस) के लिए इन विकल्पों को फिर से छोड़ देता हूं।

कार्यक्रम यहाँ छिपा हुआ है

#include <ctime> #include "stdio.h" #define MaxMax 17 #define Forward 1 // 1-   0 -  #define Version 1 // 0-   1 -   int hod[MaxMax+1],nf[MaxMax+1],oc[MaxMax+1],sm[MaxMax+1]; int lvl,count,nhod; #if Version==0 int pos[MaxMax+1]; inline void Start(int Max) { for (int i=0; i<Max; i++) oc[i]=0; for (int i=0; i<Max; ++i) pos[i]=1; pos[Max]=0; }; inline void FirstStep(int Max) { hod[lvl]=0; nf[lvl]=1; }; inline int ValidStep() { if ( (pos[hod[lvl]]==1) && ((nf[lvl]==1) || (pos[hod[lvl]+1]==1)) ) return 1; else return 0; }; inline void MakeStep(void) { pos[hod[lvl]]=0; --count; if (nf[lvl]==2) { pos[hod[lvl]+1]=0; --count; }; }; inline void DownStep(int Max) { ++lvl; oc[lvl]=0; hod[lvl]=-1; nf[lvl]=2; }; inline void RemoveStep(void) { pos[hod[lvl]]=1; ++count; if (nf[lvl]==2) { pos[hod[lvl]+1]=1; ++count; }; }; inline void NextStep(void) { if ((nf[lvl]==1) && (lvl>0)) nf[lvl]=2; else { ++hod[lvl]; nf[lvl]=1; }; }; inline int LastStep(int Max) {if (hod[lvl]>=Max) return 1; else return 0; }; void print(int Max) { for (int i=0; i<Max; ++i) if (pos[i]==1) printf("*"); else printf("."); for (int i=0; i<Max; ++i) if (i<=lvl) printf ("%2d,%1d",hod[i],nf[i]); else printf(" "); printf("%3d ",count); for (int i=0; i<Max; ++i) printf("%3d",oc[i]); printf("\n"); }; #endif #if Version==1 int gr[MaxMax+1]; inline void Start(int Max) { for (int i=0; i<Max; i++) oc[i]=0; for (int i=0; i<MaxMax; ++i) { gr[i]=0; }; gr[Max]=1; }; inline void FirstStep(int Max) { hod[lvl]=Max; nf[lvl]=1; sm[lvl]=0; }; inline int ValidStep(void) { if ( (gr[hod[lvl]]>0) && (hod[lvl]>=nf[lvl]) ) return 1; else return 0; }; inline void MakeStep(void) { gr[hod[lvl]]-=1; gr[hod[lvl]-nf[lvl]-sm[lvl]]+=1; if (sm[lvl]>0) gr[sm[lvl]]+=1; count-=nf[lvl]; }; inline void NextStep(void) { sm[lvl]++; if ( sm[lvl]*2 > (hod[lvl]-nf[lvl]) ) { if ( (lvl>0) && (nf[lvl]==1) ) { nf[lvl]=2; sm[lvl]=0; } else { hod[lvl]-=1; sm[lvl]=0; nf[lvl]=1; }; }; }; inline void DownStep(int Max) { ++lvl; oc[lvl]=0; hod[lvl]=Max; nf[lvl]=1; sm[lvl]=0; }; inline void RemoveStep(void) { if (sm[lvl]>0) gr[sm[lvl]]-=1; gr[hod[lvl]-nf[lvl]-sm[lvl]]-=1; gr[hod[lvl]]+=1; count+=nf[lvl]; }; inline int LastStep(int Max) {if (hod[lvl]<=0) return 1; else return 0; }; void print(int Max) { if (Max==18) { for (int i=1; i<=Max; ++i) printf("%2d,",gr[i]); for (int i=0; i<Max; ++i) if (i<=lvl) printf (" =>%2d:%2d,%1d,%2d",i,hod[i],nf[i],sm[i]); else printf(" "); printf(" %3d:: ",count); for (int i=0; i<Max; ++i) printf("%2d",oc[i]); printf("\n"); }; }; #endif inline void MoveOc(void) { int newoc=-oc[lvl+1]; if (newoc>0) ++newoc; else --newoc; if ( (oc[lvl]==0) || ( (oc[lvl]<0) && (newoc>0) ) || ( (oc[lvl]>0) && (newoc>0) && (newoc<oc[lvl]) ) || ( (oc[lvl]<0) && (newoc<0) && (newoc<oc[lvl]) ) ) { oc[lvl]=newoc; // if (oc[0]>0) --ur; }; }; int ocenka(int Max) { Start(Max); count=Max; nhod=0; lvl=0; FirstStep(Max); while (lvl>=0) { //print(Max); if ( ValidStep()==1) { MakeStep(); ++nhod; //print(Max); if (count>0) DownStep(Max); else { #if Forward==1 oc[lvl]=1; #else if (oc[lvl]==0) oc[lvl]=-1; #endif RemoveStep(); }; //print(Max); }; NextStep(); if (LastStep(Max)==1) { --lvl; if (lvl>-1) { MoveOc(); RemoveStep(); NextStep(); }; }; }; return nhod; }; void reverse(void); int main(void) { int last=1; for (int i=1; i<=MaxMax; ++i) { clock_t start_time = clock(); int j=ocenka(i); printf("%2d %3d %12d %5.2f %5.2f\n",i,oc[0],j,(float)j/last,(clock()-start_time)/1000.); last=j; }; return 1; };

Wirth और जंजीरों के सवाल के लिए

एल्गोरिदम + डेटा संरचनाएं = कार्यक्रम - पुण्य एन।

"हमारे पास एक छोटा लेकिन अत्यंत शिक्षाप्रद सामरिक अभ्यास करने का शानदार अवसर था"

— , , . , , ( ) .

More articles: