ตัวอย่างของอัลกอริทึมแบบเรียกซ้ำที่ซับซ้อน

ผมได้อธิบายที่มีชื่อเสียงกำหนดขั้นตอนวิธีการเลือกเส้นเวลา (ค่ามัธยฐานของอัลกอริทึมมีเดีย) ให้เพื่อน

การเรียกซ้ำในอัลกอริทึมนี้ (ในขณะที่เรียบง่ายมาก) นั้นค่อนข้างซับซ้อน มีการเรียกซ้ำสองครั้งแต่ละครั้งมีพารามิเตอร์แตกต่างกัน

ฉันพยายามค้นหาตัวอย่างอื่น ๆ ของอัลกอริทึมแบบเรียกซ้ำที่น่าสนใจ แต่ไม่สามารถหาได้ อัลกอริธึมการเรียกซ้ำทั้งหมดที่ฉันสามารถทำได้คือการเรียกซ้ำแบบง่าย ๆ หรือการแบ่งและพิชิตอย่างง่าย

คุณช่วยยกตัวอย่างการเรียกซ้ำที่ซับซ้อนได้ไหม

การเกิดขึ้นอีกครั้งที่ชื่นชอบของฉันแสดงในอัลกอริทึมที่ไวต่อการส่งออกสำหรับการคำนวณเปลือกนูนครั้งแรกโดยKirkpatrick และ Seidelแต่ทำซ้ำในภายหลังโดยคนอื่น ๆ ให้หมายถึงเวลาในการคำนวณเปลือกนูนของnจุดในเครื่องบินเมื่อเปลือกนูนมีชั่วโมงจุด ( ไม่ทราบค่าของเอชล่วงหน้านอกเหนือจากขอบเขตที่ไม่สำคัญh ≤ n .) อัลกอริทึมของเคิร์กแพททริกและเซเดลทำให้เกิดการกลับเป็นซ้ำ T ( n , h ) = { O ( n ) $T(n,h)$$n$$h$$h$$h\le n$ ที่n1,n2≤3n/4และn1+n2=nและเอช1+H2=ชั่วโมง

$$T(n,h) = \begin{cases} O(n) & \text{if }n \le 3 \text{ or } h \le 3 \\ T(n_1, h_1) + T(n_2, h_2) + O(n) & \text{otherwise} \end{cases}$$ $n_1, n_2 \le 3n/4$$n_1 + n_2 = n$$h_1 + h_2 = h$

การแก้ปัญหาคือ ) มันน่าแปลกใจนิดหน่อยเนื่องจากhไม่ได้เป็นพารามิเตอร์ที่แบ่งเท่า ๆ กัน แต่ในความเป็นจริงที่เลวร้ายที่สุดกรณีของการเกิดซ้ำที่เกิดขึ้นเมื่อเอช1และเอช2มีทั้งที่เกี่ยวกับเอช/ 2 ; ถ้าอย่างใดอย่างน่าอัศจรรย์ชั่วโมง1เป็นค่าคงที่เสมอ, การแก้ปัญหาจะเป็นT ( n , H ) = O ( n )$T(n,h) = O(n\log h)$$h$$h_1$$h_2$$h/2$$h_1$$T(n,h) = O(n)$

ฉันใช้ตัวแปรของการเกิดซ้ำในเอกสารโทโพโลยีการคำนวณครั้งแรกของฉัน : ที่

$$T(n,g) = \begin{cases} O(n) & \text{if }n \le 3 \text{ or } g = 0\\ T(n_1, g_1) + T(n_2, g_2) + O(\min\{n_1, n_2\}) & \text{otherwise} \end{cases}$$ และ g 1 + $n_1 + n_2 = n$กรัม อีกครั้งวิธีแก้ปัญหาคือ O ( n log g )และกรณีที่เลวร้ายที่สุดเกิดขึ้นเมื่อทั้ง nและ gถูกแบ่งเท่า ๆ กัน$g_1 + g_2 = g$$O(n\log g)$$n$$g$

การเรียกซ้ำที่ฉันใช้ในบทความของฉัน "อัลกอริทึมเชิงเส้นเวลาสำหรับการคำนวณแผนภาพ Voronoi ของรูปหลายเหลี่ยมนูน" โดย Aggarwal et alก็ค่อนข้างซับซ้อนเช่นกัน

นี่คือคำอธิบายของอัลกอริทึมจากบทความของเรา ในกรณีที่ยังไม่ชัดเจนจากคำอธิบายในขั้นตอนที่ 3 จุดสีแดงจะถูกแบ่งเป็นจุดสีแดงเข้มและสีแดงโกเมน ขั้นตอนที่ 1, 3 และ 6 เป็นเวลาเชิงเส้นทั้งหมด เราก็รู้ว่าถ้า$n$ คือจำนวนคะแนนทั้งหมด $|\mathrm{B}| \geq \alpha n$, $|\mathrm{R}| \geq \beta n$, and $|\mathrm{C}| \geq \gamma n$ for some $\alpha, \beta, \gamma > 0$.

I'll let you figure out why the entire algorithm takes linear time.

1. Partition the original points into the blue and red sets B and R.
2. Recursively compute the convex hull of the blue points.
3. Using the structure of the blue hull, select the crimson points C.
4. Add the crimson points to the blue hull one at a time.
5. Recursively compute the convex hull of the garnet points G.
6. Merge this garnet hull with the expanded blue hull of step 4.

What makes the algorithm linear is the ability to add a fixed fraction of the red points to the blue hull at constant cost per point. The points added are the crimson points.

The recursion is thus

$$T(n) = T(|B|) + T(|G|) + O(n)$$ where you don't know $|B|$ and $|G|$ but are guaranteed that $|B| + |G| \leq (1-\gamma) n$.

There is a variation on the median finding recurrence that comes from range searching with halfplanes. The recurrence itself is of the form

$$T(n) = T(n/2) + T(n/4) + cn$$ which is similar to the median-finding recurrence. For more on this, look at Jeff Erickson's lecture notes and in particular Section 4.

There are a bunch of cool recursive algorithms [1], [2] used in RNA secondary structure prediction. Left to its own devices, a strand of RNA will form base pairs with itself; one relatively simple example from [3] computes the maximum number of nested, paired bases an RNA string will form with itself:

$M(i,j)=\underset{i\leq k < j - L_{min}}{max} \begin{cases} M(i,k-1)+ M(k+1, j-1)+1 \\M(i, j-1) \end{cases}$

---

1. Optimal computer folding of large RNA sequences using thermodynamics and auxiliary information by M. Zuker, P. Stiegler (1981)

2. A Dynamic Programming Algorithm for RNA Structure Prediction Including Pseudoknots by E. Rivas, S. R. Eddy (1999)

3. Fast algorithm for predicting the secondary structure of single-stranded RNA by R. Nussinov, A. B. Jacobson (1980)

I still don't really understand what you mean by "sophisticated recursion". For example, the recursion step in the FFT algorithm is sophisticated!

แต่ถ้าคุณต้องการค้นหาการเรียกซ้ำที่ซับซ้อนกว่าการสอบถามซ้ำซึ่งกันและกันอาจเป็นคำตอบที่เป็นไปได้ recursion ร่วมกันจะเป็นประโยชน์เมื่อทำงานร่วมกับการเขียนโปรแกรมภาษา Fuctional recursion รวมเป็นคุณลักษณะที่สำคัญของparsers โคตร recursive

จากด้านบนของหัวฉันฟังก์ชัน McCarthy 91

F(N) = 
    n - 100    if n > 100
    F(F(n+11)) if n <= 100

และฟังก์ชั่น Ackermann

A(m, n) = 
    n + 1             if m = 0
    A(m-1, 1)         if m > 0 and n = 0
    A(m-1, A(m, n-1)) if m > 0 and n > 0

อาจนับว่าผิดปรกติถึงแม้ว่าจะเป็นฟังก์ชั่นแบบเรียกซ้ำ