Beispiele für ausgefeilte rekursive Algorithmen

Ich habe einem Freund den berühmten deterministischen linearen Zeitauswahlalgorithmus (Median des Medianalgorithmus) erklärt.

Die Rekursion in diesem Algorithmus ist (obwohl sehr einfach) ziemlich ausgefeilt. Es gibt zwei rekursive Aufrufe mit jeweils unterschiedlichen Parametern.

Ich habe versucht, andere Beispiele für solche interessanten rekursiven Algorithmen zu finden, konnte aber keine finden. Alle rekursiven Algorithmen, die mir einfallen könnten, sind entweder einfache Schwanzrekursionen oder einfaches Teilen und Erobern (wobei die beiden Aufrufe "gleich" sind).

Können Sie einige Beispiele für anspruchsvolle Rekursionen nennen?

Meine Lieblingswiederholung taucht in ausgangssensitiven Algorithmen zur Berechnung konvexer Hüllen auf, zuerst von Kirkpatrick und Seidel , aber später von anderen wiederholt. Es sei die Zeit zum Berechnen der konvexen Hülle von n Punkten in der Ebene, wenn die konvexe Hülle h Eckpunkte hat. (Der Wert von h ist im Voraus nicht bekannt, abgesehen von der trivialen Grenze h ≤ n .) Der Kirkpatrick- und Seidel-Algorithmus liefert die Wiederholung T ( n , h ) = { O ( n ) $T(n,h)$$n$$h$$h$$h\le n$ wobein1,n2≤3n/4undn1+n2=nundh1+h2=h.

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

Die Lösung ist . Dies ist ein wenig überraschend, da h nicht der Parameter ist, der gleichmäßig aufgeteilt wird. Tatsächlich tritt der schlimmste Fall der Wiederholung auf, wenn h 1 und h 2 beide ungefähr h / 2 sind ; wenn irgendwie magisch h 1 immer konstant ist, wäre die Lösung 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)$

Ich habe eine Variante dieser Wiederholung in einer meiner ersten Arbeiten zur Computertopologie verwendet : wo

$$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}$$ und g 1 + g 2 = g . Wieder ist die Lösung O ( n log g ) , und derschlimmsteFall tritt auf, wenn sowohl n als auch g immer gleichmäßig aufgeteilt werden.$n_1 + n_2 = n$$g_1 + g_2 = g$$O(n\log g)$$n$$g$

Die Rekursion, die ich in meiner Arbeit "Ein linearer Zeitalgorithmus zur Berechnung des Voronoi-Diagramms eines konvexen Polygons" von Aggarwal et al. Verwendet habe, ist ebenfalls ziemlich kompliziert.

$n$$|\mathrm{B}| \geq \alpha n$$|\mathrm{R}| \geq \beta n$$|\mathrm{C}| \geq \gamma n$$\alpha, \beta, \gamma > 0$

Ich werde Sie herausfinden lassen, warum der gesamte Algorithmus lineare Zeit benötigt.

1. Teilen Sie die ursprünglichen Punkte in die blauen und roten Sätze B und R.
2. Berechnen Sie rekursiv die konvexe Hülle der blauen Punkte.
3. Wählen Sie anhand der Struktur des blauen Rumpfs die purpurroten Punkte C aus.
4. Fügen Sie die purpurroten Punkte einzeln zum blauen Rumpf hinzu.
5. Berechnen Sie rekursiv die konvexe Hülle der Granatpunkte G.
6. Verbinden Sie diesen Granatrumpf mit dem erweiterten blauen Rumpf von Schritt 4.

Was den Algorithmus linear macht, ist die Fähigkeit, einen festen Bruchteil der roten Punkte zu konstanten Kosten pro Punkt zum blauen Rumpf hinzuzufügen. Die hinzugefügten Punkte sind die purpurroten Punkte.

$$T(n) = T(|B|) + T(|G|) + O(n)$$ $|B|$$|G|$$|B| + |G| \leq (1-\gamma) n$

Es gibt eine Variation des Medianwerts für das Wiederauffinden von Wiederholungen, die bei der Entfernungssuche mit Halbebenen auftreten. Die Wiederholung selbst ist von der Form

$$T(n) = T(n/2) + T(n/4) + cn$$

Es gibt eine Reihe von coolen rekursiven Algorithmen [1], [2] die bei der Vorhersage von RNA-Sekundärstrukturen verwendet werden. Ein RNA-Strang, der sich selbst überlassen bleibt, bildet mit sich selbst Basenpaare. Ein relativ einfaches Beispiel aus [3] berechnet die maximale Anzahl verschachtelter, gepaarter Basen, die ein RNA-String mit sich selbst bilden wird:

$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. Optimale Computerfaltung großer RNA-Sequenzen mit Hilfe von Thermodynamik und Hilfsinformationen von M. Zuker, P. Stiegler (1981)

2. Ein dynamischer Programmieralgorithmus zur Vorhersage der RNA-Struktur mit Pseudoknoten von E. Rivas, SR Eddy (1999)

3. Schneller Algorithmus zur Vorhersage der Sekundärstruktur von einzelsträngiger RNA von R. Nussinov, AB Jacobson (1980)

Ich verstehe immer noch nicht wirklich, was Sie unter "raffinierter Rekursion" verstehen. Zum Beispiel ist der Rekursionsschritt im FFT-Algorithmus komplex!

Wenn Sie jedoch nach einer komplizierteren Rekursion suchen möchten , ist die gegenseitige Rekursion möglicherweise eine mögliche Antwort. Die gegenseitige Rekursion ist nützlich, wenn Sie mit funktionalen Programmiersprachen arbeiten . Die gegenseitige Rekursion ist das Hauptmerkmal von Parsern für rekursive Abstammung .

Die McCarthy 91 funktioniert auf Anhieb

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

und die Ackermann-Funktion

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

könnte als ungewöhnliche, wenn auch spielzeughafte, rekursive Funktionen gelten.