ปัญหาฮีป d-ary จาก CLRS

ฉันสับสนในขณะที่แก้ปัญหาต่อไปนี้ (คำถาม 1-3)

คำถาม

dกอง -ary เป็นเหมือนกองไบนารี แต่ (ยกเว้นที่เป็นไปได้อย่างใดอย่างหนึ่ง) โหนดที่ไม่ใช่ใบมีdเด็กแทนเด็ก 2

1. คุณจะเป็นตัวแทนของกองd -ary ในอาร์เรย์ได้อย่างไร?

2. ความสูงของคืออะไรdกอง -ary ของnองค์ประกอบในแง่ของnและd ?

3. ให้การใช้งาน EXTRACT-MAX อย่างมีประสิทธิภาพในd -ary max-heap วิเคราะห์เวลาในการทำงานในแง่ของdและn

4. _{นำ INSERT ไปใช้อย่างมีประสิทธิภาพด้วยd -ary max-heap วิเคราะห์เวลาในการทำงานในแง่ของdและn}

5. _{ให้การนำไปใช้อย่างมีประสิทธิภาพของ INCREASE-KEY ( A , i , k ) ซึ่งทำเครื่องหมายข้อผิดพลาดหากk <A [i] = k จากนั้นอัพเดตโครงสร้างd -ary matrix heap อย่างเหมาะสม วิเคราะห์เวลาในการทำงานในแง่ของ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. ให้hหมายถึงความสูงของกองd -ary

   สมมติว่า heap เป็นต้นไม้สมบูรณ์d -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 -th ด้านบน$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)])$$

   → นี่เป็นวิธีที่มีประสิทธิภาพหรือไม่ หรือมีบางอย่างผิดปกติในโซลูชันของฉัน

1. โซลูชันของคุณถูกต้องและเป็นไปตามคำจำกัดความของd -ary heap แต่เมื่อคุณชี้ให้เห็นสัญกรณ์ของคุณค่อนข้างซับซ้อน

   คุณอาจใช้ทั้งสองฟังก์ชันต่อไปนี้เพื่อดึงพาเรนต์ขององค์ประกอบi -th และj -th ย่อยขององค์ประกอบi -th

   $\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$

   เห็นได้ชัดว่าd คุณสามารถตรวจสอบฟังก์ชั่นเหล่านั้นได้โดยตรวจสอบว่า$1 \le j \le d$$\text{d-ary-parent}(\text{d-ary-child}(i,j)) = i$

   นอกจากนี้ยังมองเห็นได้ง่ายคือ heap แบบไบนารีเป็นแบบพิเศษของ -ary heap โดยที่หากคุณแทนที่ด้วยคุณจะเห็นว่าฟังก์ชันตรงกับฟังก์ชันผู้ปกครอง, ซ้ายและขวาที่ระบุไว้ในหนังสือ$d$$d=2$$d$$2$

2. ถ้าผมเข้าใจคำตอบของคุณอย่างถูกต้องคุณใช้ความก้าวหน้าทางเรขาคณิต ในกรณีของคุณคุณจะได้ไปซึ่งเห็นได้ชัดซึ่งอันที่จริงแล้วเป็นโซลูชันที่ถูกต้องและถูกต้อง แต่เพียงเพื่อประโยชน์ของการจัดการความผันผวนอย่างต่อเนื่องคุณอาจต้องการที่จะเขียน(n))$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}$

   เพราะไม่ได้เปลี่ยนแปลงก็ขึ้นอยู่กับเวลาการทำงานของ{MAX-HEAPIFY} ในการวิเคราะห์ของคุณตอนนี้คุณต้องใช้เวลากรณีเลวร้ายที่สุดตามสัดส่วนสูงและจำนวนลูกที่แต่ละโหนดจะต้องตรวจสอบ (ซึ่งมากที่สุดง ) การวิเคราะห์ของคุณแม่นยำอีกครั้งในตอนท้ายคุณจะได้ซึ่งสามารถเปลี่ยนเป็น:$\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โน้ตแล้วเราจะได้รับ(n)) ซึ่งเป็นโซลูชันที่ถูกต้อง แต่ไม่น่าแปลกใจที่คุณยังสามารถวิเคราะห์เวลาทำงานฟังก์ชั่นการใช้ทฤษฎีบทโทซึ่งจะแสดงให้เห็นว่าไม่ได้เป็นเพียงแต่แม้\$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)$

   มันสามารถพิสูจน์ได้ง่าย แต่สามัญสำนึกสั่งที่ซับซ้อนที่เวลามันคือ(n)) อาจเป็นเพราะกองอาจเข้าไปในรูตทั้งหมด$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))$

นี่ไม่ใช่คำตอบที่สมบูรณ์ ส่วน b) โซลูชันไม่ใช่ มัน ตามที่ผู้ใช้ 55463 ชี้ (เพราะเขาไม่สามารถแสดงความคิดเห็น แต่ตอบ) แต่ downvoted เพราะขาดคำอธิบาย . คำตอบที่อัปโหลดได้แก้ไขไปอย่างผิดพลาดเช่นกัน คำตอบจะยังคงเป็น ที่มา: ปัญหา 2-2 การวิเคราะห์ d -ary heaps ส่วน b)

คำตอบสำหรับคำถามที่สองคือ h = log _d (n (d-1) + 1) - 1 ดังนั้น h = log _d (nd - n + 1) - 1