फूट डालो और जीतो का एक क्लासिक अनुप्रयोग निम्नलिखित समस्या को हल करना है:
एक सरणी को देखते हुए अलग, तुलनीय तत्वों की, सरणी में उलट जोड़े की संख्या की गिनती: जोड़े ( मैं , जे ) ऐसी है कि एक [ मैं ] > एक [ जे ] और मैं < j ।
इसके लिए एक दृष्टिकोण मर्ज सॉर्ट करना है, लेकिन उप-समस्याओं में उलटा जोड़े की संख्या की गिनती भी है। मर्ज के चरण के दौरान, हम उलटा युग्मों की संख्या की गणना करते हैं जो (दो) उप-समस्याओं में होती हैं और उप-समस्याओं की गिनती में जोड़ते हैं।
हालांकि यह अच्छा है, और एक टाइम एल्गोरिथ्म देता है, यह सरणी को गड़बड़ करता है।
यदि हमारे पास अतिरिक्त बाधा है कि सरणी केवल-पढ़ने के लिए है, तो हम प्रतिलिपि बना सकते हैं और कॉपी के साथ सौदा कर सकते हैं, या एक अतिरिक्त डेटा-संरचना का उपयोग कर सकते हैं जैसे गिनती करने के लिए एक आदेश आँकड़ों के संतुलित बाइनरी ट्री का उपयोग करते हैं, दोनों का उपयोग स्थान।
वर्तमान प्रश्न दौड़ के समय को प्रभावित न करते हुए, स्थान को बेहतर बनाने का प्रयास करना है। अर्थात
क्या उलटा जोड़े की संख्या की गणना करने के लिए एक समय एल्गोरिथ्म है, जो एक रीड-ओनली सरणी पर काम करता है और उप-लीनियर (यानी ओ ( एन ) ) स्पेस का उपयोग करता है?
मान लें कि एक समान लागत वाला रैम मॉडल और तत्व स्थान लेते हैं और उनके बीच तुलना ओ ( 1 ) है ।
एक संदर्भ होगा, लेकिन एक स्पष्टीकरण बेहतर होगा :-)
मैंने वेब खोजने की कोशिश की, लेकिन इसके लिए कोई सकारात्मक / नकारात्मक उत्तर नहीं मिला। मुझे लगता है कि यह सिर्फ एक जिज्ञासा है।