सीएलआरएस से डी-एरी हीप समस्या

Question

मैं निम्नलिखित समस्या को हल करते समय भ्रमित हो गया (प्रश्न १-३)।

सवाल

एक डी -ढेर ढेर एक बाइनरी हीप की तरह है, लेकिन (एक संभावित अपवाद के साथ) गैर-पत्ती नोड्स में 2 बच्चों के बजाय डी बच्चे हैं।

1. आप किसी सरणी में d -ary ढेर का प्रतिनिधित्व कैसे करेंगे ?

2. N और d के संदर्भ में n तत्वों के d -ary ढेर की ऊंचाई कितनी है ?

3. एक में EXTRACT-मैक्स की एक कुशल कार्यान्वयन दें घ -ary अधिकतम-ढेर। D और n के संदर्भ में इसके चलने के समय का विश्लेषण करें ।

4. _{एक में सम्मिलित करें का एक कुशल कार्यान्वयन दें घ -ary अधिकतम-ढेर। D और n के संदर्भ में इसके चलने के समय का विश्लेषण करें ।}

5. _{INCREASE-KEY ( A , i , k ) का एक कुशल कार्यान्वयन दें , जो k <A [i] = k के होने पर त्रुटि को चिह्नित करता है और फिर d -ary मैट्रिक्स हीप संरचना को उचित रूप से अपडेट करता है। D और n के संदर्भ में इसके चलने के समय का विश्लेषण करें ।}

मेरा समाधान

1. एक सरणी$A[a_1 .. a_n]$

   $\qquad \begin{align} \text{root} &: a_1\\ \text{level 1} &: a_{2} \dots a_{2+d-1}\\ \text{level 2} &: a_{2+d} \dots a_{2+d+d^2-1}\\ &\vdots\\ \text{level k} &: a_{2+\sum\limits_{i=1}^{k-1}d^i} \dots a_{2+\sum\limits_{i=1}^{k}d^i-1} \end{align}$

   → मेरा अंकन थोड़ा परिष्कृत लगता है। क्या कोई और सरल है?

2. चलो ज की ऊंचाई को दर्शाता है घ -ary ढेर।

   मान लीजिए कि ढेर एक पूरा हो गया है घ -ary पेड़

   $$1+d+d^2+..+d^h=n\\ \dfrac{d^{h+1}-1}{d-1}=n\\ h=log_d[n{d-1}+1] - 1$$

3. यह मेरा कार्यान्वयन है:

   EXTRACT-MAX(A)
   1  if A.heapsize < 1
   2      error "heap underflow"
   3  max = A[1]
   4  A[1] = A[A.heapsize]
   5  A.heap-size = A.heap-size - 1
   6  MAX-HEAPIFY(A, 1)
   7  return max
   
   MAX-HEAPIFY(A, i)
   1  assign depthk-children to AUX[1..d]
   2  for k=1 to d
   3      compare A[i] with AUX[k]
   4      if A[i] <= AUX[k]
   5          exchange A[i] with AUX[k]
   6          k = largest
   7  assign AUX[1..d] back to A[depthk-children]
   8  if largest != i
   9      MAX-HEAPIFY(A, (2+(1+d+d^2+..+d^{k-1})+(largest-1) )
   

   • MAX-HEAPIFY का समय चल रहा है:

     ग

     $$T_M = d(c_8*d + (c_9+..+c_13)*d +c_14*d)$$ जहाँ ऊपर i लाइन की लागत को दर्शाता है।$c_i$

   • EXTRACT-MAX:

     $$T_E = (c_1+..+c_7) + T_M \leq C*d*h\\ = C*d*(log_d[n(d-1)+1] - 1)\\ = O(dlog_d[n(d-1)])$$

   → क्या यह एक कुशल उपाय है? या मेरे समाधान के भीतर कुछ गड़बड़ है?

Comments

मुझे लगता है कि प्रश्न के साथ-साथ स्पष्टीकरण में थोड़ी सी भी गलती है: d-ary हीप की ऊंचाई h = (लॉग [nd - n + 1]) तक आती है - 1 // इसका "-n" नोट करें और नहीं "-1" और h = (log [nd−1+1])− 1इस प्रकार हम ऊंचाई के लिए स्पष्टीकरण से ऊपर नहीं हैं। h = log [nd + 1 + 1] =1 = log [nd] -1 = log [n] हालांकि, फिर भी, पेड़ की ऊंचाई Θ(log(n)).नोट के रूप में लिखी जाती है : लॉग हमेशा d-ary ढेर के लिए आधार d पर होता है ।

— सुरभि राजे

Answer 1

1. आपका समाधान मान्य है और d -ary ढेर की परिभाषा इस प्रकार है । लेकिन जैसा कि आपने बताया कि आपकी धारणा थोड़ी परिष्कृत है।

   आप उन दो निम्नलिखित कार्यों का उपयोग की मूल पुनः प्राप्त करने के सकता है मैं मई के तत्व और जे के मई के बच्चे मैं मई के तत्व।

   $\text{d-ary-parent}({\it i}) \\ \ \ \ \ {\bf return}\ \lfloor (i-2)/d + 1 \rfloor$

   $\text{d-ary-child}(i, j) \\ \ \ \ \ {\bf return}\ d(i-1)+j+1$

   स्पष्ट रूप से । आप उन कार्यों की जाँच कर सकते हैं जो उस जाँच कर रहे हैं$1 \le j \le d$$\text{d-ary-parent}(\text{d-ary-child}(i,j)) = i$

   इसके अलावा आसान देखने के लिए कि द्विआधारी ढेर के विशेष प्रकार है -ary ढेर जहां , यदि आप स्थानापन्न के साथ , तो आप यह है कि वे कार्यों माता पिता, वाम से मेल खाते हैं और दाएं पुस्तक में उल्लेख किया देखेंगे।$d$$d=2$$d$$2$

2. यदि मैं आपके उत्तर को सही ढंग से समझता हूं तो आप एक ज्यामितीय प्रगति का उपयोग करते हैं । आपके मामले में आपको , जो स्पष्ट रूप से , जो वास्तव में एक वैध और सही समाधान है। लेकिन निरंतर उतार-चढ़ाव से निपटने के लिए आप लिखना चाह सकते हैं ।$h = log_d(n\,d-1+1) - 1$$\log_d(n\,d) - 1 = \log_d(n) + \log_d(d) - 1 = \log_d(n) + 1 - 1 = \log_d(n)$$\Theta(\log_d(n))$

   इसका कारण यह है कि कुछ ढेर संतुलित नहीं हो सकते हैं, इसलिए उनका सबसे लंबा रास्ता और सबसे छोटा रास्ता कुछ निरंतर भिन्न होता है , इस समस्या को समाप्त करने के लिए संकेतन का उपयोग करके ।$c$$\Theta$

3. आपको पाठ्यपुस्तक में दी गई प्रक्रिया को फिर से लागू करने की आवश्यकता नहीं है, लेकिन आपको इसे थोड़ा बदलना होगा, उदाहरण के लिए दिए गए और का उपयोग करके सभी बच्चों को तालिका में असाइन करना। कार्य करता है।$AUX$$\text{d-ary-parent}$$\text{d-ary-child}$

   चूँकि को परिवर्तित नहीं किया गया था, इसलिए यह चलने के समय पर निर्भर करता है । अपने विश्लेषण में आप अब आप hight और बच्चों की संख्या के लिए बुरी से बुरी हालत समय आनुपातिक का उपयोग करना चाहिए जो प्रत्येक नोड विचार करना चाहिए (जो ज्यादा से ज्यादा है घ )। एक बार फिर आपका विश्लेषण बहुत सटीक है, अंत में आपको , जिसे निम्न में रूपांतरित किया जा सकता है:$\text{EXTRACT-MAX}$$\text{MAX-HEAPIFY}$$O(d\ \log_d(n(d-1)))$

   $O(d\ \log_d(n(d-1))) = O(d(\log_d(n) + \log(d-1))) = O(d\ log_d(n) + d\ \log_d(d-1))$

   व्यावहारिक कारणों से हम हमेशा मान सकते हैं कि , इसलिए हम O संकेतन के भाग को खो सकते हैं , फिर हमें । जो मान्य समाधान भी है। लेकिन आश्चर्य नहीं कि आप मास्टर प्रमेय का उपयोग करके फ़ंक्शन रन टाइम का विश्लेषण भी कर सकते हैं , जो यह दिखाएगा कि केवल नहीं है, बल्कि भी है ।$d \ll n$$d \log_d(d-1)$$O(d\log_d(n))$$\text{MAX-HEAPIFY}$$O$$\Theta$

4. CLRS पुस्तक पहले से ही INSERT प्रक्रिया प्रदान करती है। जो इस तरह दिखता है:

   $\text{INSERT}(A, key)\\ \ \ \ \ A.heap\_size = A.heap\_size + 1 \\ \ \ \ \ A[A.heap\_size] = -\infty\\ \ \ \ \ \text{INCREASE-KEY}(A, A.heap\_size, key)$

   यह आसान सिद्ध हो सकता है लेकिन सामान्य ज्ञान यह है कि यह समय की जटिलता है । यह इसलिए है क्योंकि ढेर जड़ के लिए सभी तरह से लगाया जा सकता है।$O(\log_d(n))$

5. INSERT की तरह, INCREASE-KEY को भी पाठ्यपुस्तक में इस प्रकार परिभाषित किया गया है:

   $\text{INCREASE-KEY}(A, i, key)\\ \ \ \ \ {\bf if}\ key < A[i]\\ \ \ \ \ \ \ \ \ {\bf error} \text{"new key is smaller then current"}\\ \ \ \ \ A[i] = key\\ \ \ \ \ {\bf while}\ i > 1\ and\ A[i] > A[\text{d-ary-parent}(i)]\\ \ \ \ \ \ \ \ \ A[i] \leftrightarrow A[\text{d-ary-parent(i)}]\\ \ \ \ \ \ \ \ \ i = \text{d-ary-parent(i)}$

   जटिलता स्पष्ट रूप से (पिछले बिंदु को देखें)।$O(\log_d(n))$

Comments

धन्यवाद! INCREASE-KEY और INSERT के कार्यान्वयन के बारे में कैसे? मैं इसे लिखने की कोशिश करता हूं, लेकिन इसने MAX-HEAPIFY की दो बार पुनरावर्ती कॉल दी। क्या कोई बेहतर समाधान है? मुझे वेब और विकी

— lucasKo

क्या यह बाकी व्यायाम है? यदि ऐसा है तो कृपया अपने प्रश्न को अपडेट करें और मुझे विषय का उत्तर देने में खुशी होगी।

— बार्टोज़ प्रेज़ीबल्स्की

मैंने उन सवालों को संपादित पोस्ट पर डाल दिया।

— lucasKo

INSERT प्रक्रिया को फिर से लागू करें? आप मतलब है, यह प्रक्रिया है कि ढेर के भीतर आदेश को समायोजित करता है, एक नया तत्व डालने के बाद कॉल करने के लिए नहीं है? मुझे यह नहीं मिला ...

— lucasKo

यह विवरण थोड़ा दुर्भाग्यपूर्ण था, स्पष्टीकरण के लिए संपादन देखें।

— बार्टोज़ प्रेज़ीबेल्स्की

Answer 2

यह पूर्ण उत्तर नहीं है। भाग b) समाधान इसका जैसा कि उपयोगकर्ता 55463 द्वारा इंगित किया गया है (क्योंकि वह टिप्पणी नहीं कर सकता है, लेकिन उत्तर), लेकिन स्पष्टीकरण की कमी के कारण अस्वीकृत । अपवोट उत्तर ने भी गलती से इसे हल कर दिया है। उत्तर अभी भी स्रोत: समस्या 2-2 होगा। D -ary ढेर का विश्लेषण, भाग b)

$$h=log_d[n{d-1}+1] - 1$$ ज = Θ ( लॉग घ ( एन ) $$1+d+d^2+..+d^h=n\\ \dfrac{d^{h+1}-1}{d-1}=n\\ h=log_d[n(d-1)+1] - 1$$ $$h=\Theta(\log_d(n))$$

Answer 3

दूसरे प्रश्न का उत्तर h = log _d (n (d-1) + 1) है - 1 इसलिए, h = log _d (nd - n + 1) - 1

Comments

इसका जवाब क्यों है? बिना किसी स्पष्टीकरण के एक सूत्र वास्तव में किसी की मदद नहीं करता है।

— डेविड रिचरबी