यह पहले वाला प्रश्न कुछ ऐसे कारकों को संबोधित करता है जिनके कारण एल्गोरिथ्म में O (लॉग एन) जटिलता हो सकती है।
क्या एल्गोरिथ्म का कारण समय जटिलता हे (लॉग लॉग एन) होगा?
यह पहले वाला प्रश्न कुछ ऐसे कारकों को संबोधित करता है जिनके कारण एल्गोरिथ्म में O (लॉग एन) जटिलता हो सकती है।
क्या एल्गोरिथ्म का कारण समय जटिलता हे (लॉग लॉग एन) होगा?
जवाबों:
O (लॉग लॉग एन) शब्द विभिन्न स्थानों पर दिखाई दे सकते हैं, लेकिन आमतौर पर दो मुख्य मार्ग हैं जो इस रनटाइम पर पहुंचेंगे।
जैसा कि लिंक किए गए प्रश्न के उत्तर में उल्लेख किया गया है, एल्गोरिथ्म के लिए समय जटिलता ओ (लॉग एन) के लिए एक सामान्य तरीका है कि एल्गोरिथ्म प्रत्येक पुनरावृत्ति पर कुछ निरंतर कारक द्वारा इनपुट के आकार को बार-बार काटकर काम करने के लिए है। यदि यह स्थिति है, तो एल्गोरिथ्म को O (लॉग एन) पुनरावृत्तियों के बाद समाप्त होना चाहिए, क्योंकि ओ (लॉग एन) विभाजनों को स्थिर करने के बाद, एल्गोरिथ्म को समस्या का आकार 0 या 1 से कम करना चाहिए। यही कारण है, उदाहरण के लिए बाइनरी खोज में जटिलता हे (लॉग एन) है।
दिलचस्प बात यह है कि समस्या के आकार को छोटा करने का एक समान तरीका है जो फॉर्म ओ (लॉग लॉग एन) के रनटाइम्स देता है। प्रत्येक परत पर इनपुट को आधे में विभाजित करने के बजाय, यदि हम प्रत्येक परत पर आकार का वर्गमूल लेते हैं तो क्या होता है ?
उदाहरण के लिए, आइए 65,536 नंबर लें। जब तक हम 1 से नीचे नहीं हो जाते, तब तक हमें कितनी बार इसे 2 से विभाजित करना होगा? यदि हम ऐसा करते हैं, हम प्राप्त करते हैं
इस प्रक्रिया में 16 कदम होते हैं, और यह भी मामला है कि 65,536 = 2 16 ।
लेकिन, यदि हम प्रत्येक स्तर पर वर्गमूल लेते हैं, तो हम प्राप्त करते हैं
ध्यान दें कि यह सभी रास्ते नीचे लाने के लिए केवल चार कदम उठाता है। 2. यह क्यों है?
सबसे पहले, एक सहज व्याख्या। N और theren की संख्या में कितने अंक हैं? संख्या n में लगभग लॉग एन अंक हैं, और लगभग लॉग (=n) = लॉग (एन 1/2) हैं ) = (1/2) लॉग एन अंकों में digitn हैं। इसका मतलब है कि, हर बार जब आप एक वर्गमूल लेते हैं, तो आप संख्या में अंकों की संख्या को लगभग आधा कर देते हैं। चूँकि आप केवल मात्रा k O (लॉग k) समय को एक स्थिरांक (2, 2) तक नीचे जाने से पहले रोक सकते हैं, इसका मतलब यह है कि आप संख्या को कम करने से पहले केवल वर्गमूल O (log log n) बार ही ले सकते हैं। कुछ स्थिर (कहने के लिए, 2)।
अब, इस कठोर बनाने के लिए कुछ गणित करते हैं। लेट्स दो की शक्तियों के संदर्भ में उपरोक्त अनुक्रम को फिर से लिखते हैं:
ध्यान दें कि हमने अनुक्रम 2 16 → 2 8 → 2 4 → 2 2 → 2 1 का पालन किया । प्रत्येक पुनरावृत्ति पर, हम आधे में दो की शक्ति के घातांक को काटते हैं। यह दिलचस्प है, क्योंकि यह हमें पहले से ही पता है कि वापस जोड़ता है - आप शून्य से ड्रॉप करने से पहले संख्या k को आधे O (लॉग k) समय में विभाजित कर सकते हैं।
तो कोई भी नंबर n लें और इसे n = 2 k के रूप में लिखें । हर बार जब आप n का वर्गमूल लेते हैं, तो आप इस समीकरण में घातांक को आधा कर देते हैं। इसलिए, केवल 1 या उससे कम (जिस स्थिति में n 2 से या उससे कम हो जाता है) ड्रॉप करने से पहले O (लॉग k) वर्गमूल लागू हो सकते हैं। N = 2 k के बाद से , इसका मतलब है कि k = log 2 n, और इसलिए ली गई वर्गमूलों की संख्या O (लॉग k) = O (लॉग लॉग n) है। इसलिए, अगर एल्गोरिथ्म है जो बार-बार समस्या को कम करके आकार के एक उपप्रोब्लेम में काम करता है जो कि मूल समस्या आकार का वर्गमूल है, तो वह एल्गोरिथ्म O (लॉग लॉग एन) चरणों के बाद समाप्त हो जाएगा।
इसका एक वास्तविक विश्व उदाहरण वैन एमड बोस पेड़ है(vEB- पेड़) डेटा संरचना। VEB- ट्री 0 में पूर्णांक बनाने के लिए एक विशेष डेटा संरचना है ... N - 1. यह निम्नानुसार काम करता है: पेड़ के मूल नोड में pointN पॉइंटर्स होते हैं, जो सीमा 0 को विभाजित करते हैं ... N - 1 roughN बाल्टियों में प्रत्येक में लगभग gersN पूर्णांकों की एक सीमा होती है। ये बाल्टियाँ तब प्रत्येक आंतरिक रूप से d (buck N) बाल्टियों में विभाजित होती हैं, जिनमें से प्रत्येक में लगभग √ (√ N) तत्व होते हैं। पेड़ को पार करने के लिए, आप जड़ से शुरू करते हैं, यह निर्धारित करते हैं कि आप किस बाल्टी से संबंधित हैं, फिर पुन: उपयुक्त उपप्रकार में जारी रखें। जिस तरह से vEB- ट्री संरचित है, उसके कारण आप O (1) समय में निर्धारित कर सकते हैं कि कौन सी जगह पर उतरना है, और इसलिए O (लॉग लॉग एन) चरणों के बाद आप पेड़ के नीचे तक पहुंच जाएंगे। तदनुसार, vEB- ट्री में लुकअप में केवल O (लॉग लॉग एन) समय लगता है।
एक और उदाहरण है हॉपक्राफ्ट-फॉर्च्यून की सबसे नज़दीकी जोड़ी एल्गोरिथम । यह एल्गोरिदम 2 डी अंकों के संग्रह में दो निकटतम बिंदुओं को खोजने का प्रयास करता है। यह बाल्टियों का एक ग्रिड बनाकर और उन बाल्टियों में अंक बांटकर काम करता है। यदि एल्गोरिथ्म के किसी भी बिंदु पर एक बाल्टी पाया जाता है, जिसमें inN से अधिक अंक हैं, तो एल्गोरिथ्म उस बाल्टी को पुनरावर्ती रूप से संसाधित करता है। पुनरावृत्ति की अधिकतम गहराई इसलिए O (लॉग लॉग n) है, और पुनरावर्तन वृक्ष के विश्लेषण का उपयोग करके यह दिखाया जा सकता है कि वृक्ष की प्रत्येक परत O (n) कार्य करती है। इसलिए, एल्गोरिथ्म का कुल रनटाइम O (n लॉग लॉग एन) है।
कुछ अन्य एल्गोरिदम हैं जो आकार ओ (लॉग इन) की वस्तुओं पर बाइनरी खोज जैसे एल्गोरिदम का उपयोग करके ओ (लॉग लॉग एन) रनटाइम प्राप्त करते हैं। उदाहरण के लिए, एक्स-फास्ट ट्राई डेटा संरचना ऊंचाई ओ के पेड़ (लॉग यू) की परतों पर एक द्विआधारी खोज करता है, इसलिए इसके कुछ संचालन के लिए रनटाइम ओ (लॉग लॉग यू) हैं। संबंधित y- फास्ट ट्राई अपने O (लॉग लॉग यू) रनटाइम्स में से कुछ को O (लॉग यू) के संतुलित BST को बनाए रखता है, जिससे उन पेड़ों की खोज O (लॉग लॉग यू) में चलने की अनुमति मिलती है। टैंगो पेड़ और संबंधित multisplay पेड़ डेटा संरचनाओं एक हे (लॉग लॉग एन) उनके विश्लेषण में इस शब्द आ सकती है क्योंकि वे पेड़ों कि हे (लॉग एन) आइटम प्रत्येक शामिल बनाए रखें।
अन्य एल्गोरिदम अन्य तरीकों से रनटाइम O (लॉग लॉग एन) प्राप्त करते हैं। इंटरपोलेशन खोज ने क्रमबद्ध सरणी में संख्या खोजने के लिए रनटाइम ओ (लॉग लॉग एन) की उम्मीद की है, लेकिन विश्लेषण काफी शामिल है। अंततः, विश्लेषण यह दिखाते हुए काम करता है कि पुनरावृत्तियों की संख्या संख्या k के समान है जो n 2 -k log 2 है, जिसके लिए लॉग लॉग n सही समाधान है। कुछ एल्गोरिदम, जैसे चेरिटॉन-टारजन एमएसटी एल्गोरिदम , एक जटिल बाधा अनुकूलन समस्या को हल करके हे (लॉग लॉग एन) को शामिल करते हुए एक रनटाइम पर पहुंचते हैं।
उम्मीद है की यह मदद करेगा!
समय जटिलता में हे (लॉग लॉग एन) के कारक को देखने का एक तरीका विभाजन है जैसे सामान अन्य उत्तर में समझाया गया है, लेकिन इस कारक को देखने का एक और तरीका है, जब हम समय और स्थान / समय के बीच व्यापार करना चाहते हैं और एल्गोरिथ्म का अनुमान / समय और कठोरता / ... और हमारे एल्गोरिथ्म पर कुछ कृत्रिम चलना है।
उदाहरण के लिए SSSP (सिंगल सोर्स शॉर्टएस्ट पाथ) में प्लानर ग्राफ पर O (n) एल्गोरिदम है, लेकिन इससे पहले कि जटिल एल्गोरिथ्म रनिंग टाइम O (n लॉग लॉग एन) के साथ कहीं अधिक आसान एल्गोरिदम (लेकिन अभी भी कठिन) था, एल्गोरिथ्म का आधार इस प्रकार है (बस बहुत मोटा वर्णन, और मैं इस भाग को समझने और उत्तर के अन्य भाग को पढ़ने की पेशकश करूँगा):
लेकिन मेरी बात यह है, यहाँ हम O (लॉग एन / (लॉग लॉग एन)) के आकार के विभाजन को चुनते हैं। यदि हम O (लॉग एन / (लॉग लॉग एन) ^ 2) जैसे अन्य डिवीजनों को चुनते हैं जो तेजी से चल सकता है और एक और परिणाम लाता है। मेरा मतलब है, कई मामलों में (जैसे सन्निकटन एल्गोरिदम या यादृच्छिक एल्गोरिदम, या ऊपर जैसा SSSP जैसे एल्गोरिदम), जब हम किसी चीज़ पर सबरेट करते हैं (उपप्रोग्राम, संभव समाधान, ...), तो हम उसी के व्यापार के अनुरूप पुनरावृत्ति की संख्या चुनते हैं। हमारे पास एल्गोरिथ्म का समय / स्थान / जटिलता / एल्गोरिथ्म का निरंतर कारक, ...) है। तो क्या हम वास्तविक कार्य एल्गोरिदम में "लॉग लॉग एन" की तुलना में अधिक जटिल सामान देख सकते हैं।