View source for मास्टर प्रमेय (एल्गोरिदम का विश्लेषण)

{{short description|Bounds recurrence relations that occur in the analysis of divide and conquer algorithms}}
{{For|अन्य प्रमेय जिन्हें ''मास्टर प्रमेय'' कहा जाता है|मास्टर प्रमेय (बहुविकल्पी){{!}}मास्टर प्रमेय}}

एल्गोरिदम के विश्लेषण में, विभाजन और जीत पुनरावृत्ति के लिए मास्टर प्रमेय कई विभाजन और जीत एल्गोरिदम के विश्लेषण में होने वाले प्रकार के [[पुनरावृत्ति संबंध|पुनरावृत्ति संबंधों]] के लिए [[स्पर्शोन्मुख विश्लेषण]] ([[बिग ओ नोटेशन]] का उपयोग करके) प्रदान करता है। यह दृष्टिकोण पहली बार 1980 में [[जॉन बेंटले (कंप्यूटर वैज्ञानिक)]], [[डोरोथिया ब्लोस्टीन]] (नी हेकेन) और जेम्स बी सक्से द्वारा प्रस्तुत किया गया था, जहां इसे इस तरह की पुनरावृत्ति का समाधान करने के लिए एकीकृत विधि के रूप में वर्णित किया गया था।<ref>{{citation | last1 = Bentley | first1 = Jon Louis | author1-link = Jon Bentley (computer scientist) | last2 = Haken | first2 = Dorothea | author2-link = Dorothea Blostein | last3 = Saxe | first3 = James B. | author3-link = James B. Saxe | date = September 1980 | doi = 10.1145/1008861.1008865 | issue = 3 | journal = [[ACM SIGACT News]] | pages = 36–44 | title = A general method for solving divide-and-conquer recurrences | volume = 12| s2cid = 40642274 | url = http://www.dtic.mil/get-tr-doc/pdf?AD=ADA064294 | archive-url = https://web.archive.org/web/20170922231154/http://www.dtic.mil/get-tr-doc/pdf?AD=ADA064294 | url-status = dead | archive-date = September 22, 2017 }}</ref> मास्टर प्रमेय का नाम  व्यापक रूप से उपयोग किए जाने वाले एल्गोरिदम पाठ्यपुस्तक [[एल्गोरिदम का परिचय]] (एल्गोरिदम टेक्स्टबुक इंट्रोडक्शन टू एल्गोरिदम) द्वारा थॉमस एच. कॉर्मेन, चार्ल्स ई. लीसरसन, [[रॉन रिवेस्ट]] और [[क्लिफर्ड स्टीन]] द्वारा  लोकप्रिय किया गया था।

इस प्रमेय के उपयोग से सभी पुनरावृत्ति संबंधों को हल नहीं किया जा सकता है; इसके सामान्यीकरण में अकरा-बाज़ी पद्धति शामिल है।

== परिचय ==
समस्या पर विचार करें जिसे पुनरावर्ती एल्गोरिथम का उपयोग करके हल किया जा सकता है जैसे कि निम्नलिखित:<syntaxhighlight lang="d">
procedure p(input x of size n):
    if n < some constant k:
        Solve x directly without recursion
    else:
        Create a subproblems of x, each having size n/b
        Call procedure p recursively on each subproblem
        Combine the results from the subproblems
</syntaxhighlight>[[File:Recursive_problem_solving.svg|thumb|right|359x359px|समाधान ट्री।]]उपरोक्त एल्गोरिथ्म समस्या को पुनरावर्ती रूप से कई उप-समस्याओं में विभाजित करता है, प्रत्येक उप-समस्या आकार {{math|''n''/''b''}} की होती है. इसके समाधान के पेड़ में प्रत्येक पुनरावर्ती कॉल के लिए एक नोड होता है, उस नोड के बच्चे उस कॉल से किए गए अन्य कॉल होते हैं। पेड़ की पत्तियां पुनरावर्तन के आधार मामले हैं, उप-समस्याएं (के से कम आकार की) जो पुनरावर्तन नहीं करती हैं। उपरोक्त उदाहरण होगा {{mvar|a}} प्रत्येक गैर-पत्ती नोड पर चाइल्ड नोड। प्रत्येक नोड काम की मात्रा करता है जो उप-समस्या {{mvar|n}} के आकार के अनुरूप होता है  पुनरावर्ती कॉल के उस उदाहरण को पास किया गया और इसके <math>f(n)</math> द्वारा दिया गया . संपूर्ण एल्गोरिथम द्वारा किए गए कार्य की कुल राशि ट्री में सभी नोड्स द्वारा किए गए कार्य का योग है।

एल्गोरिथम का रनटाइम जैसे आकार 'n' के इनपुट पर ऊपर 'p', आमतौर पर <math>T(n)</math> द्वारा निरूपित किया जाता है, पुनरावृत्ति संबंध द्वारा व्यक्त किया जा सकता है
:<math>T(n) = a \; T\left(\frac{n}{b}\right) + f(n),</math>
जहाँ <math> f(n)</math> उपरोक्त प्रक्रिया में उप-समस्याओं को बनाने और उनके परिणामों को संयोजित करने का समय है। किए गए कार्य की कुल राशि के लिए व्यंजक प्राप्त करने के लिए इस समीकरण को क्रमिक रूप से स्वयं में प्रतिस्थापित किया जा सकता है और विस्तारित किया जा सकता है।<ref>
    Duke University,
    "Big-Oh for Recursive Functions: Recurrence Relations",
    http://www.cs.duke.edu/~ola/ap/recurrence.html
</ref> मास्टर प्रमेय इस रूप के कई पुनरावृत्ति संबंधों को पुनरावर्ती संबंध का विस्तार किए बिना सीधे बिग Θ-संकेतन में परिवर्तित करने की अनुमति देता है।

== सामान्य रूप ==

मास्टर प्रमेय हमेशा विभाजित और जीत एल्गोरिदम से पुनरावृत्ति के लिए असम्बद्ध रूप से तंग सीमा उत्पन्न करता है जो इनपुट को समान आकार के छोटे उप-समस्याओं में विभाजित करता है, उप-समस्याओं को पुनरावर्ती रूप से हल करता है, और फिर मूल समस्या का समाधान देने के लिए उप-समस्या समाधानों को जोड़ता है। इस तरह के एल्गोरिथ्म के लिए समय उस कार्य को जोड़कर व्यक्त किया जा सकता है जो वे अपने पुनरावर्तन के शीर्ष स्तर पर (समस्याओं को उप-समस्याओं में विभाजित करने के लिए और फिर उप-समस्याओं के समाधानों को संयोजित करने के लिए) एक साथ एल्गोरिथ्म के पुनरावर्ती कॉल में किए गए समय के साथ करते हैं। अगर <math>T(n)</math> आकार के इनपुट पर एल्गोरिथ्म के लिए कुल समय <math>n</math> को दर्शाता है, और <math>f(n)</math> पुनरावृत्ति के शीर्ष स्तर पर लगने वाले समय की मात्रा को दर्शाता है तो समय को पुनरावृत्ति संबंध द्वारा व्यक्त किया जा सकता है जो रूप लेता है:
:<math>T(n) = a \; T\!\left(\frac{n}{b}\right) + f(n)</math>
यहाँ <math>n</math> एक इनपुट समस्या का आकार है, <math>a</math> पुनरावर्तन में उपसमस्याओं की संख्या है, और <math>b</math> वह कारक है जिसके द्वारा प्रत्येक पुनरावर्ती कॉल (b> 1) में उप-समस्या का आकार कम हो जाता है। महत्वपूर्ण रूप से, <math>a</math> और <math>b</math> पर <math>n</math> निर्भर नहीं होना चाहिए. नीचे दिया गया प्रमेय यह भी मानता है कि, पुनरावृत्ति के आधार मामले के रूप में, <math>T(n)=\Theta(1)</math> कब <math>n</math> किसी <math>\kappa > 0</math> सीमा से कम है, सबसे छोटा इनपुट आकार जो पुनरावर्ती कॉल की ओर ले जाएगा।

समस्या को विभाजित/पुन: संयोजित करने के कार्य के आधार पर, इस फ़ॉर्म की पुनरावृत्ति अक्सर निम्नलिखित तीन शासनों में से एक को संतुष्ट करती है <math>f(n)</math> महत्वपूर्ण घातांक <math>c_{\operatorname{crit}}=\log_b a</math>. (नीचे दी गई तालिका मानक बिग ओ नोटेशन का उपयोग करती है) से संबंधित है।

:<math>c_{\operatorname{crit}} = \log_b a = \log(\#\text{subproblems})/\log(\text{relative subproblem size})</math>

{| class="wikitable"
|-
! width=10|स्थिति
! विवरण
! <math>f(n)</math> <math>c_{\operatorname{crit}}</math> के संबंध में, यानी, <math>\log_b a</math> पर स्थिति 
! मास्टर प्रमेय बाध्य
! width=400|सांकेतिक उदाहरण
|-


! 1
| किसी समस्या को विभाजित/पुन: संयोजित करने का कार्य उप-समस्याओं से बौना हो जाता है।
यानी पुनरावर्तन वृक्ष पत्ती-भारी है
| जब <math>f(n) = O(n^{c})</math> जहाँ <math>c<c_{\operatorname{crit}}</math> 

(कम एक्सपोनेंट बहुपद द्वारा ऊपरी-सीमित)

| ... तब <math>T(n)= \Theta\left( n^{c_{\operatorname{crit}}} \right)</math>

(विभाजन शब्द प्रकट नहीं होता है; पुनरावर्ती वृक्ष संरचना हावी है।)

| यदि <math>b=a^2</math> and <math>f(n) = O(n^{1/2-\epsilon})</math>, तब <math>T(n) = \Theta(n^{1/2})</math>.

|-


! 2
| किसी समस्या को विभाजित/पुन: संयोजित करने का कार्य उप-समस्याओं के बराबर है।
| जब<math>f(n) = \Theta(n^{c_{\operatorname{crit}}}\log^{k} n)</math> के लिये a <math>k \ge 0</math>

(महत्वपूर्ण-प्रतिपादक बहुपद द्वारा सीमाबद्ध, शून्य या अधिक वैकल्पिक <math>\log</math>s)

| ... तब <math>T(n)= \Theta\left( n^{c_{\operatorname{crit}}} \log^{k+1} n \right)</math>

(बाध्य बंटवारे की अवधि है, जहां लॉग को एक शक्ति द्वारा संवर्धित किया जाता है।)

| यदि <math>b=a^2</math> and <math>f(n) = \Theta(n^{1/2})</math>, फिर <math>T(n) = \Theta(n^{1/2} \log n)</math>.

यदि <math>b=a^2</math> और <math>f(n) = \Theta(n^{1/2} \log n)</math>, तब <math>T(n) = \Theta(n^{1/2} \log^{2} n)</math>.

|-


! 3
| किसी समस्या को विभाजित/पुन: संयोजित करने का कार्य उप-समस्याओं पर हावी हो जाता है।
यानी रिकर्सन ट्री रूट-हैवी है।
| जब <math>f(n) = \Omega(n^{c})</math> जहाँ <math>c>c_{\operatorname{crit}}</math> 

(अधिक-प्रतिपादक बहुपद द्वारा निम्न-परिबद्ध)

| ... यह आवश्यक रूप से कुछ भी नहीं देता है। इसके अलावा, अगर 

:<math>a f\left( \frac{n}{b} \right) \le k f(n)</math> for कुछ स्थिर <math>k < 1</math> और और काफी बड़ा <math>n</math> (अक्सर नियमितता की स्थिति कहा जाता है)

तो कुल बंटवारे की अवधि का प्रभुत्व है <math>f(n)</math>:

:<math>T\left(n \right) = \Theta\left(f(n) \right)</math>

| यदि <math>b=a^2</math> और <math>f(n) = \Omega(n^{1/2+\epsilon})</math> और फिर नियमितता की स्थिति <math>T(n) = \Theta(f(n))</math> बनी रहती है.

|}
केस 2 का एक उपयोगी विस्तार सभी मूल्यों को संभालता है <math>k</math>:<ref name="Yap">
Chee Yap, A real elementary approach to the master recurrence and generalizations, Proceedings of the 8th annual conference on Theory and applications of models of computation (TAMC'11), pages 14–26, 2011. [https://web.archive.org/web/20180428180729/https://pdfs.semanticscholar.org/5273/51a915d7f34f8965c74ecf422e70cd410b52.pdf Online copy.]
</ref>

{| class="wikitable"
|-
! width=10|स्थिति
! <math>f(n)</math> <math>c_{\operatorname{crit}}</math> के संबंध में, यानी,  <math>\log_b a</math> पर स्थिति
! मास्टर प्रमेय बाध्य
! width=400|सांकेतिक उदाहरण

|-

! 2a
| When <math>f(n) = \Theta(n^{c_{\operatorname{crit}}}\log^{k} n)</math> for any <math>k > -1</math>

| ... then <math>T(n)= \Theta\left( n^{c_{\operatorname{crit}}} \log^{k+1} n \right)</math>

(The bound is the splitting term, where the log is augmented by a single power.)

| If <math>b=a^2</math> and <math>f(n) = \Theta(n^{1/2}/\log^{1/2} n)</math>, then <math>T(n) = \Theta(n^{1/2} \log^{1/2} n)</math>.

|-

! 2b
| When <math>f(n) = \Theta(n^{c_{\operatorname{crit}}}\log^{k} n)</math> for <math>k = -1</math>

| ... then <math>T(n)= \Theta\left( n^{c_{\operatorname{crit}}} \log \log n \right)</math>

(The bound is the splitting term, where the log reciprocal is replaced by an iterated log.)

| If <math>b=a^2</math> and <math>f(n) = \Theta(n^{1/2}/\log n)</math>, then <math>T(n) = \Theta(n^{1/2} \log \log n)</math>.

|-

! 2c
| When <math>f(n) = \Theta(n^{c_{\operatorname{crit}}}\log^{k} n)</math> for any <math>k < -1</math>

| ... then <math>T(n)= \Theta\left( n^{c_{\operatorname{crit}}} \right)</math>

(The bound is the splitting term, where the log disappears.)

| If <math>b=a^2</math> and <math>f(n) = \Theta(n^{1/2}/\log^2 n)</math>, then <math>T(n) = \Theta(n^{1/2})</math>.

|}


=== उदाहरण ===

==== पहला उदाहरण ====
:<math>T(n) = 8 T\left(\frac{n}{2}\right) + 1000n^2</math>
जैसा कि उपरोक्त सूत्र से देखा जा सकता है:

:<math>a = 8, \, b = 2, \, f(n) = 1000n^2</math>, इसलिए
:<math>f(n) = O\left(n^c\right)</math>, जहाँ <math>c = 2</math>
अगला, हम देखते हैं कि क्या हम केस 1 शर्त को पूरा करते हैं:
:<math>\log_b a = \log_2 8 = 3>c</math>.

यह मास्टर प्रमेय के पहले मामले से अनुसरण करता है

:<math>T(n) = \Theta\left( n^{\log_b a} \right) = \Theta\left( n^{3} \right)</math>
(इस परिणाम की पुष्टि पुनरावृत्ति संबंध के सटीक समाधान से होती है, जो है <math>T(n) = 1001 n^3 - 1000 n^2</math>, मानते हुए <math>T(1) = 1</math>).

==== केस 2 उदाहरण ====
<math>T(n) = 2 T\left(\frac{n}{2}\right) + 10n</math>
जैसा कि हम उपरोक्त सूत्र में देख सकते हैं कि चरों को निम्नलिखित मान मिलते हैं:

:<math>a = 2, \, b = 2, \, c = 1, \, f(n) = 10n</math>
:<math>f(n) = \Theta\left(n^{c} \log^{k} n\right)</math> जहाँ <math>c = 1, k = 0</math>
अगला, हम देखते हैं कि क्या हम केस 2 शर्त को पूरा करते हैं:
:<math>\log_b a = \log_2 2 = 1</math>, और इसलिए, सी और <math>\log_b a</math> बराबर हैं

तो यह मास्टर प्रमेय के दूसरे मामले से आता है:

:<math>T(n) = \Theta\left( n^{\log_b a} \log^{k+1} n\right) = \Theta\left( n^{1} \log^{1} n\right) = \Theta\left(n \log n\right)</math> इस प्रकार दिया गया पुनरावृत्ति संबंध <math>T(n)</math> में था <math>\Theta(n \log n)</math>.

(इस परिणाम की पुष्टि पुनरावृत्ति संबंध के सटीक समाधान से होती है, जो है <math>T(n) = n + 10 n\log_2 n</math>, मानते हुए <math>T(1) = 1</math>).

==== केस 3 उदाहरण ====
:<math>T(n) = 2 T\left(\frac{n}{2}\right) + n^2</math>
जैसा कि हम उपरोक्त सूत्र में देख सकते हैं कि चरों को निम्नलिखित मान मिलते हैं:

:<math>a = 2, \, b = 2, \, f(n) = n^2</math>
:<math>f(n) = \Omega\left(n^c\right)</math>, जहाँ <math>c = 2</math>
अगला, हम देखते हैं कि क्या हम केस 3 शर्त को पूरा करते हैं:
:<math>\log_b a = \log_2 2 = 1</math>, और इसलिए, हाँ, <math>c > \log_b a</math>
नियमितता की स्थिति भी रखती है:

:<math> 2 \left(\frac{n^2}{4}\right) \le k n^2 </math>, चुनना <math> k = 1/2 </math>
तो यह मास्टर प्रमेय के तीसरे मामले से आता है:

:<math>T \left(n \right) = \Theta\left(f(n)\right) = \Theta \left(n^2 \right).</math>
इस प्रकार दिया गया पुनरावृत्ति संबंध <math>T(n)</math> में था <math>\Theta(n^2)</math>, जो इसका अनुपालन करता है <math>f(n)</math> मूल सूत्र का।

(इस परिणाम की पुष्टि पुनरावृत्ति संबंध के सटीक समाधान से होती है, जो है <math>T(n) = 2 n^2 - n</math>, मानते हुए <math>T(1) = 1</math>.)

== अस्वीकार्य समीकरण ==
मास्टर प्रमेय का उपयोग करके निम्नलिखित समीकरणों को हल नहीं किया जा सकता है:<ref>
    Massachusetts Institute of Technology (MIT),
    "Master Theorem: Practice Problems and Solutions",
    https://people.csail.mit.edu/thies/6.046-web/master.pdf
</ref>
*<math>T(n) = 2^nT\left (\frac{n}{2}\right )+n^n</math>
*: a स्थिरांक नहीं है; उप-समस्याओं की संख्या निश्चित की जानी चाहिए
*<math>T(n) = 2T\left (\frac{n}{2}\right )+\frac{n}{\log n}</math>
*: के बीच गैर-बहुपद अंतर <math>f(n)</math> और <math>n^{\log_b a}</math> (नीचे देखें; विस्तारित संस्करण लागू होता है)
*<math>T(n) = 0.5T\left (\frac{n}{2}\right )+n</math>
*:<math> a<1 </math> एक से कम उप समस्या नहीं हो सकती
*<math>T(n) = 64T\left (\frac{n}{8}\right )-n^2\log n</math>
*:<math>f(n)</math>, जो संयोजन समय है, सकारात्मक नहीं है
*<math>T(n) = T\left (\frac{n}{2}\right )+n(2-\cos n)</math>
*:केस 3 लेकिन नियमितता का उल्लंघन।

उपरोक्त दूसरे अस्वीकार्य उदाहरण में, के बीच का अंतर <math>f(n)</math> और <math>n^{\log_b a}</math> अनुपात में व्यक्त किया जा सकता है <math>\frac{f(n)}{n^{\log_b a}} = \frac{n / \log n}{n^{\log_2 2}} = \frac{n}{n \log n} = \frac{1}{\log n}</math>. यह स्पष्ट है कि <math>\frac{1}{\log n} < n^\epsilon</math> किसी स्थिरांक के लिए <math>\epsilon > 0</math>. इसलिए, अंतर बहुपद नहीं है और मास्टर प्रमेय का मूल रूप लागू नहीं होता है। विस्तारित रूप (केस 2बी) समाधान देते हुए लागू होता है <math>T(n) = \Theta(n\log\log n)</math>.

== सामान्य एल्गोरिदम के लिए आवेदन ==
{| class="wikitable"
|-
! Algorithm
! Recurrence relationship
! Run time
! Comment
|-
| [[Binary search]]
| <math>T(n) = T\left(\frac{n}{2}\right) + O(1)</math>
| <math>O(\log n)</math>
| Apply Master theorem case <math>c = \log_b a</math>, where <math>a = 1, b = 2, c = 0, k = 0</math><ref name="dartmouth">
    Dartmouth College,
    http://www.math.dartmouth.edu/archive/m19w03/public_html/Section5-2.pdf
</ref>
|-
| Binary tree traversal
| <math>T(n) = 2 T\left(\frac{n}{2}\right) + O(1)</math>
| <math>O(n)</math>
| Apply Master theorem case <math>c < \log_b a</math> where <math>a = 2, b = 2, c = 0</math><ref name="dartmouth" />
|-
| Optimal sorted matrix search
| <math>T(n) = 2 T\left(\frac{n}{2}\right) + O(\log n)</math>
| <math>O(n)</math>
| Apply the [[Akra–Bazzi theorem]] for <math>p=1</math> and <math>g(u)=\log(u)</math> to get <math>\Theta(2n - \log n)</math> 
|-
| [[Merge sort]]
| <math>T(n) = 2 T\left(\frac{n}{2}\right) + O(n)</math>
| <math>O(n \log n)</math>
| Apply Master theorem case <math>c = \log_b a</math>, where <math>a = 2, b = 2, c = 1, k = 0</math>
|}


== यह भी देखें ==

* एकरा–बाजी विधि
* [[स्पर्शोन्मुख जटिलता]]

== टिप्पणियाँ ==
{{reflist}}


== संदर्भ ==
* [[Thomas H. Cormen]], [[Charles E. Leiserson]], [[Ronald L. Rivest]], and [[Clifford Stein]]. ''[[Introduction to Algorithms]]'', Second Edition. MIT Press and McGraw–Hill, 2001. {{ISBN|0-262-03293-7}}. Sections 4.3 (The master method) and 4.4 (Proof of the master theorem), pp.&nbsp;73&ndash;90.
* [[Michael T. Goodrich]] and [[Roberto Tamassia]]. ''Algorithm Design: Foundation, Analysis, and Internet Examples''. Wiley, 2002. {{ISBN|0-471-38365-1}}. The master theorem (including the version of Case 2 included here, which is stronger than the one from CLRS) is on pp.&nbsp;268–270.

{{DEFAULTSORT:Master Theorem}}[[Category: स्पर्शोन्मुख विश्लेषण]] [[Category: कम्प्यूटेशनल जटिलता सिद्धांत में प्रमेय]] [[Category: पुनरावृत्ति संबंध]] [[Category: एल्गोरिदम का विश्लेषण]] 



[[Category: Machine Translated Page]]
[[Category:Created On 13/02/2023]]