क्या Google Code Jam Great Wall समस्या का तेज़ समाधान है

Question

निम्नलिखित Google कोड जैम 1C प्रश्न पर विचार करें :

चीन की महान दीवार एक अनंत रेखा के रूप में शुरू होती है, जहां सभी स्थानों पर ऊंचाई ।$0$

कुछ संख्याएँ जनजातियाँ , , दीवार पर निम्न मापदंडों के अनुसार दीवार पर हमला करेंगी - एक प्रारंभ दिवस, , एक प्रारंभ शक्ति , एक शुरुआत पश्चिम-समन्वय, और एक आरंभ पूर्व-समन्वय, । यह पहला हमला दिन पर होता है , , ताकत । यदि भीतर महान दीवार का कोई हिस्सा है जिसकी ऊंचाई , तो हमला सफल होता है, और दिन के अंत में, दीवार को ऐसे बनाया जाएगा कि उसका कोई भी खंड भीतर हो ऊँचाई तब ऊँचाई पर होगीएन ≤ 1000 डी एस डब्ल्यू ई डी [ डब्ल्यू , ई ] एस [ डब्ल्यू , ई ] < एस [ डब्ल्यू , ई ] < एस $N$$N \le 1000$$D$$S$$W$$E$$D$$[W,E]$$S$$[W,E]$$< S$$[W,E]$$< S$$S$ (या अधिक, अगर उस दिन कुछ अन्य हमला साथ एक ही खंड पर मारा गया तो )$S' > S$

प्रत्येक जनजाति पीछे हटने से पहले हमले करेगी, और प्रत्येक हमले को इससे पहले एक से पुनरावृत्त रूप से निर्धारित किया जाएगा। प्रत्येक जनजाति के पास कुछ , , और जो हमलों के उनके अनुक्रम को निर्धारित करते हैं: हमलों के बीच दिन इंतजार करना होगा , वे प्रत्येक हमले (नकारात्मक = पश्चिम, सकारात्मक) के लिए अपनी हमले की सीमा इकाइयों को स्थानांतरित करेंगे = पूर्व), हालांकि सीमा का आकार समान रहेगा, और प्रत्येक हमले के बाद उनकी ताकत में निरंतर मूल्य में वृद्धि / कमी होगी।δ डी δ एक्स δ एस δ डी ≥ 1 δ $1000$$\delta_D$$\delta_X$$\delta_S$$\delta_D \ge 1$$\delta_X$

समस्या का लक्ष्य हमलावर जनजातियों का संपूर्ण विवरण दिया गया है, यह निर्धारित करना कि उनके कितने हमले सफल होंगे।

मैं एक समाधान को हल करने में कामयाब रहा जो काम करता है, लगभग 20 सेकंड में चल रहा है: मेरा मानना ​​है कि मैंने जो समाधान लागू किया है वह समय है, जहां हमलों की कुल संख्या एक अनुकार (अधिकतम ), और अटैक रेंज (अधिकतम ) पर अद्वितीय बढ़त बिंदुओं की कुल संख्या ।$O(A\log A + (A+X)\log X)$$A =$$1000000$$X =$$2000000$

उच्च स्तर पर, मेरा समाधान:

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

मेरा प्रश्न यह है: क्या से बेहतर करने का कोई तरीका है ? शायद, जनजातियों के क्रमिक हमलों के रैखिक प्रकृति का लाभ उठाने के लिए कुछ रणनीतिक तरीका है? 20 सेकंड एक इच्छित समाधान के लिए बहुत लंबा लगता है (हालांकि जावा को इसके लिए दोषी ठहराया जा सकता है)।$O(A\log A + (A+X)\log X)$

Comments

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

— आर्यभट्ट

मैं इसे फिर खुला

— रखूँगा

Answer 1

सुधार के लिए स्पष्ट कमरा यह कदम है:

हर ट्राइब के सभी हमलों को जनरेट करता है, और उन्हें दिन के अनुसार क्रमबद्ध करता है - $O(A\log A)$

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

यह वास्तव में सभी मैं सैद्धांतिक जटिलता को अनुकूलित करने के लिए सुझाव दे सकता हूं, लेकिन मेरे पास कोई सबूत नहीं है कि यह इस बदलाव के बाद इष्टतम होगा।

---

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

• जैसा कि आपने बताया, बॉक्सिंग और अनबॉक्सिंग महंगा हो सकता है, लेकिन C ++ के टेम्पलेट-आधारित कंटेनर पूरी तरह से इससे बचते हैं।
• हालांकि मैंने जिस दीवार का प्रतिनिधित्व किया वह सैद्धांतिक रूप से बदतर है, अधिकांश मामलों में डायनामिक रूप से नोड्स की संख्या को कम करने में सक्षम होने के कारण इसे सुपर-फास्ट बनाया गया (अधिकांश परीक्षण मामलों को 1k नोड्स के तहत अधिकतम किया गया, और सभी लेकिन 2 10k से कम थे) । वास्तव में, कोई भी महत्वपूर्ण समय लेने वाला एकमात्र मामला # 7 था, जो लगता है कि कई गैर-अन्तर्विभाजक श्रेणियों का परीक्षण कर रहा है।
• मैंने कोई पूर्व-प्रसंस्करण का उपयोग नहीं किया (प्रत्येक जनजाति अगले हमले कब करेगी, और संयुक्त-निम्नतम प्रत्येक मोड़ की खोज के लिए ट्रैक का निर्धारण किया जाता है)। फिर से यह सैद्धांतिक रूप से बदतर है, लेकिन अधिकांश मामलों के लिए मुझे निचले ओवरहेड पर संदेह है इसका मतलब है कि यह तेज था (मैं इसे परीक्षण करूंगा और आपके पास वापस आऊंगा)। अपडेट : मैंने हमलों के लिए एक प्राथमिकता कतार को जोड़ा, जो ऊपर वर्णित विधि के समान है (हालांकि बड़े सरणी बनाने के बजाय मैंने इसे ऑन-द-फ्लाई की गणना की) और बड़े इनपुट के लिए समय घटकर 3.0 सेकंड देखा।

संक्षेप में, जब तक मुझे लगता है कि आपका एल्गोरिथ्म सामान्य मामले में निकट-इष्टतम है, ऐसे कई तरीके हैं जिनसे आप इसे विशिष्ट इनपुट के लिए गति दे सकते हैं ।

Answer 2

निम्नलिखित को प्रश्न से हटा दिया गया था, क्योंकि यह एक उत्तर है।

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

इसका समाधान यहां पाया जा सकता है । यह बहुत कुछ वैसा ही है जैसा मैंने यहाँ पोस्ट किया है; इसलिए मुझे विश्वास है कि अधिक कुशल समाधान मौजूद नहीं है।