दिलचस्प पोस्ट
415 त्रुटि असमर्थित मीडिया प्रकार: JSON को अगर POST नहीं पहुंचता है, लेकिन यह XML करता है संस्करण नियंत्रण (यानी उपवर्तन) दस्तावेज़ ट्रैकिंग में लागू है? "जार फ़ाइल तक पहुंचने में असमर्थ" त्रुटि का क्या कारण है? पायथन सॉर्ट लिस्ट सूची / चढ़ते हुए और उसके बाद डेडिंग गिट: "भ्रष्ट ढीले वस्तु" मैं Android पर एक पारदर्शी गतिविधि कैसे बनाऊं? typedef सूचक const weirdness एंड्रॉइड लप्पी प्रभाव – बटन के लिए फ़ीडबैक फ़ीड – एक्सएमएल का उपयोग करना ActiveRecord में बनाने पर आईडी ओवरराइड करना प्रोग्राम-वर्ड थीम को प्रोग्रामिंग में परिवर्तित करना? ConfigureAwait एक पूल धागा को निरंतरता धक्का स्कैनर अंतरिक्ष के बाद नहीं देखता है मैं TabControl के अंदर एक टैब कैसे अक्षम कर सकता हूं? कॉरस पर XMLHttpRequest को समझना (responseText) बाईं ओर से एक एंड्रॉइड स्लाइडिंग ड्रॉवर स्लाइड कैसे बनाई जाए?

यूक्लिड के एल्गोरिथ्म का समय जटिलता

मुझे यह तय करने में कठिनाई हो रही है कि यूक्लिड की सबसे बड़ी आम भाजक एल्गोरिथ्म का समय जटिलता क्या है छद्म कोड में यह एल्गोरिदम है:

function gcd(a, b) while b ≠ 0 t := b b := a mod b a := t return a 

यह एक और बी पर निर्भर करता है । मेरी सोच यह है कि समय की जटिलता ओ (एक% बी) है क्या वो सही है? क्या यह लिखने का एक बेहतर तरीका है?

वेब के समाधान से एकत्रित समाधान "यूक्लिड के एल्गोरिथ्म का समय जटिलता"

यूक्लिड के एल्गोरिथ्म की जटिलता का विश्लेषण करने के लिए एक युग का पालन करना है जो दो पुनरावृत्तियों पर होता है:

 a', b' := a % b, b % (a % b) 

अब ए और बी दोनों कम हो जाएंगे, केवल एक के बजाय, जो विश्लेषण को आसान बनाता है। आप इसे मामलों में विभाजित कर सकते हैं:

  • छोटा ए: 2a <= b
  • छोटे बी: 2b <= a
  • छोटा ए: 2a > b लेकिन a < b
  • छोटा बी: 2b > a लेकिन b < a
  • बराबर: a == b

अब हम दिखाएंगे कि हर एक मामले में कम से कम एक चौथाई तक कुल a+b घट जाती है:

  • छोटे ए: b % (a % b) < a 2a <= b और 2a <= b , ऐसा b कम से कम आधे से कम हो जाता है, इसलिए a+b कम से कम 25%
  • छोटे बी: a % b < b और 2b <= a , इसलिए कम से कम आधे से कम हो जाता है, इसलिए a+b कम से कम 25%
  • लघु ए: b ba बन जाएंगे, जो कि b/2 से कम है, कम से कम 25% कम करके a+b कम कर देता है।
  • छोटा बी: a ab बन जाएगा, जो कि a/2 से कम है, कम से कम 25% कम करके a+b कम कर देता है।
  • बराबर: a+b 0 गिरता है, जो स्पष्ट रूप से कम से कम 25% कम से कम a+b कम हो रहा है

इसलिए, मामले के विश्लेषण के अनुसार, प्रत्येक डबल-चरण में कम से कम 25% a+b घटता a+b । इससे पहले कि a+b को 1 नीचे ड्रॉप करने के लिए मजबूर किया जा सकता है, यह अधिकतम समय हो सकता है जब तक हम हिट नहीं करते, तब तक चरण ( S ) की कुल संख्या को पूरा करना चाहिए (4/3)^S <= A+B अब बस इसे काम करो:

 (4/3)^S <= A+B S <= lg[4/3](A+B) S is O(lg[4/3](A+B)) S is O(lg(A+B)) S is O(lg(A*B)) //because A*B asymptotically greater than A+B S is O(lg(A)+lg(B)) //Input size N is lg(A) + lg(B) S is O(N) 

तो पुनरावृत्तियों की संख्या इनपुट अंकों की संख्या में रैखिक है। सीपीयू रजिस्टरों में फिट होने वाले नंबरों के लिए, पुनरावृत्तियों को निरंतर समय लेना उचित है और दिखाते हैं कि जीसीडी का कुल चलने वाला समय रैखिक है।

बेशक, यदि आप बड़े पूर्णांक के साथ काम कर रहे हैं, तो आपको इस तथ्य के लिए खाता होना चाहिए कि प्रत्येक पुनरावृत्ति के भीतर मापांक संचालन में निरंतर लागत नहीं है मोटे तौर पर बोलते हुए, कुल असीमप्टोटिक रनटाइम एन ^ 2 बार एक पॉलिलेगैरिडामिक कारक होने वाला है। n^2 lg(n) 2^O(log* n) तरह कुछ एक द्विआधारी जीसीडी का उपयोग करके पॉलिलेगैरडिमिक कारक को बचाया जा सकता है।

एल्गोरिथ्म का विश्लेषण करने का उपयुक्त तरीका सबसे खराब स्थिति परिदृश्यों का निर्धारण कर रहा है। यूक्लिडियन जीसीडी का सबसे बुरा मामला तब होता है जब फिबोनैकी जोड़े शामिल होते हैं। void EGCD(fib[i], fib[i - 1]) , जहां मैं> 0

उदाहरण के लिए, हम इस मामले को चुनते हैं जहां लाभांश 55 है, और विभाजक 34 है (याद है कि हम अभी भी फाइबोनैचि संख्याओं के साथ काम कर रहे हैं)।

यहां छवि विवरण दर्ज करें

जैसा कि आप देख सकते हैं, इस ऑपरेशन में 8 पुनरावृत्तियों (या पुनरावर्ती कॉल) की लागत है।

चलो बड़ी फिबोनाची संख्या, 121,393 और 75025 की कोशिश करो। हम यहां पर ध्यान दे सकते हैं कि इसमें 24 पुनरावृत्तियों (या पुनरावर्ती कॉल) लगते हैं।

यहां छवि विवरण दर्ज करें

आप यह भी देख सकते हैं कि प्रत्येक पुनरावृत्तियों से फिबोनैचि संख्या उत्पन्न होती है। यही कारण है कि हमारे पास इतने सारे ऑपरेशन हैं हम वास्तव में वास्तव में फाइबोनैचि संख्याओं के साथ समान परिणाम प्राप्त नहीं कर सकते

इसलिए, समय की जटिलता को छोटे ओह (ऊपरी बाध्य) द्वारा प्रस्तुत किया जा रहा है, इस समय निचली बाध्य intuitively ओमेगा (1) है: 500 का मामला 2 से विभाजित है, उदाहरण के लिए।

चलो पुनरावृत्ति संबंध को हल करें:

यहां छवि विवरण दर्ज करें

हम कह सकते हैं कि यूक्लिडियन जीसीडी लॉग (एक्सआई) ऑपरेशन को अधिकतर पर बना सकता है

विकिपीडिया लेख पर इस पर एक महान नज़र है

यह भी मूल्य जोड़े के लिए जटिलता का एक अच्छा साजिश है

यह ओ (ए% बी) नहीं है।

यह (आलेख देखें) ज्ञात है कि यह छोटी संख्या में अंकों की संख्या में पांच गुना से अधिक कदम नहीं उठाएगा। इसलिए अधिकतम संख्या की संख्या अंकों की संख्या के रूप में बढ़ती है (एलएनबी)। प्रत्येक चरण की लागत भी अंकों की संख्या के रूप में बढ़ती है, इसलिए जटिलता ओ (ln ^ 2 b) से बाध्य होती है जहां b छोटी छोटी है। यह ऊपरी सीमा है, और वास्तविक समय आमतौर पर कम है

यहां देखें

विशेष रूप से इस भाग में:

Lamé ने दिखाया कि एन से कम दो नंबरों के लिए सबसे बड़ा सामान्य विभाजक पहुंचने के लिए आवश्यक चरणों की संख्या है

वैकल्पिक शब्द

तो O(log min(a, b)) एक अच्छा ऊपरी बाउंड है।

यूक्लिड के एल्गोरिथम की रनटाइम जटिलता के बारे में यहां सहज ज्ञान युक्त समझ है औपचारिक साक्ष्यों को विभिन्न ग्रंथों जैसे कि एल्गोरिदम और टीएओओसीपी खंड 2 की पहचान में शामिल किया गया है।

पहले हम इस बारे में सोचें कि क्या हम दो फिबोनाची संख्या एफ (के + 1) और एफ (के) के जीसीडी लेने की कोशिश कर रहे थे। आप जल्दी से यह देख सकते हैं कि यूक्लिड के एल्गोरिथम एफ (के) और एफ (के -1) को पुनरावृत्त करता है। यही है, प्रत्येक चलन के साथ हम फिबोनाची श्रृंखला में एक नंबर नीचे ले जाते हैं। फिबोनैचि संख्याएं ओ (फी ^ के) के रूप में होती हैं, जहां फ़ी सुनहरे अनुपात होती हैं, हम देख सकते हैं कि जीसीडी का क्रम समय ओ (लॉग एन) था जहां n = अधिकतम (ए, बी) और लॉग फिई का आधार है इसके बाद, हम यह साबित कर सकते हैं कि फिबोनैचि संख्या लगातार जोड़ों का उत्पादन करती है, जहां प्रत्येक चलना में रहने वाले लोग काफी बड़े होते हैं और तब तक शून्य नहीं होते जब तक कि आप श्रृंखला के शुरू में नहीं आते हैं।

हम ओ (लॉग एन) बना सकते हैं जहां n = अधिकतम (ए, बी) और भी अधिक सख्त बाध्य। मान लें कि b> = एक तो हम ओ (लॉग ख) पर बाध्य लिख सकते हैं। सबसे पहले, जीसीडी (का, केबी) = जीसीडी (ए, बी) का पालन करें। कश्मीर के सबसे बड़े मूल्यों के रूप में जीसीडी (ए, सी) है, हम बी के साथ बी / जीसीडी (ए, बी) को बदल सकते हैं, जो कि हमारे रनटाइम में है (ओपन बी / जीसीडी (ए, बी)) की अधिक बाध्य है।

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

जब n और m ए और बी के अंक की संख्या होती है, मान लीजिए n> = m, एल्गोरिथ्म ओ (मी) डिवीजनों का उपयोग करता है।

ध्यान दें कि जटिलताओं को हमेशा इनपुट के आकार के अनुसार दिया जाता है, इस मामले में अंकों की संख्या।

पुनरावृत्त एल्गोरिथ्म के लिए, हालांकि, हमारे पास:

 int iterativeEGCD(long long n, long long m) { long long a; int numberOfIterations = 0; while ( n != 0 ) { a = m; m = n; n = a % n; numberOfIterations ++; } printf("\nIterative GCD iterated %d times.", numberOfIterations); return m; } 

फाइबोनासी जोड़े के साथ, iterativeEGCD() और iterativeEGCDForWorstCase() बीच कोई अंतर नहीं है, जहां बाद में निम्न की तरह दिखता है:

 int iterativeEGCDForWorstCase(long long n, long long m) { long long a; int numberOfIterations = 0; while ( n != 0 ) { a = m; m = n; n = a - n; numberOfIterations ++; } printf("\nIterative GCD iterated %d times.", numberOfIterations); return m; } 

हां, फिबोनैकी जोड़े के साथ, n = a % n और n = a - n , यह वही चीज है

हम यह भी जानते हैं कि, एक ही प्रश्न के पूर्व उत्तर में, एक प्रचलित घटता कारक है: factor = m / (n % m)

इसलिए, एक परिभाषित रूप में यूक्लिडियन जीसीडी के पुनरावृत्त संस्करण को आकार देने के लिए, हम इस तरह एक "सिम्युलेटर" के रूप में वर्णित कर सकते हैं:

 void iterativeGCDSimulator(long long x, long long y) { long long i; double factor = x / (double)(x % y); int numberOfIterations = 0; for ( i = x * y ; i >= 1 ; i = i / factor) { numberOfIterations ++; } printf("\nIterative GCD Simulator iterated %d times.", numberOfIterations); } 

डॉ। जौहर अली के काम (अंतिम स्लाइड) के आधार पर, ऊपर लूप लारगिरिदमिक है।

यहां छवि विवरण दर्ज करें

हाँ, छोटे ओह, क्योंकि सिम्युलेटर अधिक से अधिक पुनरावृत्तियों की संख्या बताता है। यूक्लिडियन जीसीडी पर जांच किए जाने पर, गैर फिबोनाची जोड़े फिबोनैची की तुलना में कम संख्या में पुनरावृत्तियों को ले जाएगा।

गेब्रियल लैम के प्रमेय लॉग (1 / sqrt (5) * (a + 1/2)) – 2, जहां लॉग का आधार है (1 + sqrt (5)) / 2 के द्वारा चरण की संख्या को सीमा। यह एल्गोरिथ्म के लिए सबसे बुरी स्थिति scenerio के लिए है और यह तब होता है जब आदानों लगातार Fibanocci संख्या हैं।

थोड़ी अधिक उदार बाध्य है: लॉग करें, जहां लॉग का आधार है (sqrt (2)) कोब्लिट्ज़ द्वारा निहित किया गया है।

क्रिप्टोग्राफ़िक प्रयोजनों के लिए हम आम तौर पर एल्गोरिदम की बिटवर्ड जटिलता पर विचार करते हैं, यह ध्यान में रखते हुए कि बिट आकार लगभग k = लॉग द्वारा दिया गया है।

यूक्लिड एल्गोरिथ की बिटवर्ड जटिलता का विस्तृत विश्लेषण यहां दिया गया है:

यद्यपि अधिकांश संदर्भ में यूक्लिड एल्गोरिथ्म की बिटवर्ड जटिलता ओ (लॉगा) ^ 3 द्वारा दी गई है, वहां एक तंग बाध्य है जो ओ (लॉग) ^ 2 है।

विचार करें; r0 = a, r1 = b, r0 = q1.r1 + r2 । । , री-1 = qi.ri + री + 1,। । । , rm-2 = qm-1.rm-1 + rm rm-1 = qm.rm

निरीक्षण करें कि: a = r0> = b = r1> r2> r3 …> rm-1> rm> 0 ………. (1)

और आरएम एक और बी की सबसे बड़ी आम विभाजक है।

कोब्लिट्ज़ की किताब (संख्या सिद्धांत और क्रिप्टोग्राफी में एक कोर्स) में एक दावा करके यह सिद्ध किया जा सकता है कि: री + 1 <(आरआई -1) / 2 …………….. ( 2)

फिर कोबलिट्ज़ में एक बिट-बिट सकारात्मक पूर्णांक को k-bit सकारात्मक पूर्णांक को विभाजित करने के लिए आवश्यक बिट ऑपरेशन की संख्या (मान लीजिए k> = l) इस प्रकार दी गई है: (k-l + 1)। एल …… …………. (3)

(1) और (2) डिविजनों की संख्या ओ (लॉग) है और इसलिए (3) कुल जटिलता ओ (लॉग) ^ 3 है।

अब यह कोबलिट्ज़ में एक टिप्पणी द्वारा ओ (लॉग) ^ 2 तक कम किया जा सकता है।

कि = लॉरी +1 पर विचार करें

(1) और (2) हमारे पास है: i + 0,1, के लिए कि + 1 <= केआई, …, एम -2, एम -1 और कि + 2 <= (के) -1 i = 0 के लिए , 1, …, एम-2

और (3) मी डि divisons की कुल लागत से घिरा है: एसएम [(की -1) – ((की) -1))] * मैं के लिए = 0,1,2, .., मी

इसे दोबारा व्यवस्थित करना: एसएम [(की -1) – ((की) -1))] * कि <= 4 * के0 ^ 2

तो यूक्लिड के एल्गोरिद्म की बिटवर्थ जटिलता ओ (लॉग) ^ 2 है।