Esempi di sofisticati algoritmi ricorsivi

Stavo spiegando il famoso algoritmo di selezione del tempo lineare deterministico ( mediano delle mediane) ad un amico.

La ricorsione in questo algoritmo (pur essendo molto semplice) è piuttosto sofisticata. Esistono due chiamate ricorsive, ognuna con parametri diversi.

Stavo cercando di trovare altri esempi di algoritmi ricorsivi così interessanti, ma non riuscivo a trovarne nessuno. Tutti gli algoritmi ricorsivi che ho potuto escogitare sono semplici ricorsioni di coda o semplici divisioni e conquiste (dove le due chiamate sono "uguali").

Puoi fornire alcuni esempi di ricorsione sofisticata?

La mia ricorrenza preferita si presenta in algoritmi sensibili all'output per il calcolo degli scafi convessi, prima da Kirkpatrick e Seidel , ma in seguito ripetuti da altri. Sia il tempo di calcolare lo scafo convesso di n punti nel piano, quando lo scafo convesso ha h vertici. (Il valore di h non è noto in anticipo, a parte il limite banale h ≤ n .) L'algoritmo di Kirkpatrick e Seidel produce la ricorrenza T ( n , h ) = ≤ 3  o  h ≤ $T(n,h)$$n$$h$$h$$h\le n$. doven1,n2≤3n/4en1+n2=neh1+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$

La soluzione è . Questo è un po 'sorprendente, dal momento che h non è il parametro suddiviso uniformemente. Ma in realtà, il caso peggiore della ricorrenza si verifica quando h 1 e h 2 sono entrambi relativi a h / 2 ; se in qualche modo magicamente h 1 è sempre costante, la soluzione sarebbe 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)$ .

Ho usato una variante di questa ricorrenza in uno dei miei primi documenti di topologia computazionale : dove

$$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}$$ e g 1 + g 2 = g . Ancora una volta, la soluzione è O ( n log g ) e ilcasopeggiore siverifica quando entrambi$n_1 + n_2 = n$$g_1 + g_2 = g$$O(n\log g)$$n$ che sono sempre divise in modo uniforme.$g$

Anche la ricorsione che ho usato nel mio articolo "Un algoritmo a tempo lineare per calcolare il diagramma di Voronoi di un poligono convesso" di Aggarwal et al è anche abbastanza complicata.

Ecco una descrizione dell'algoritmo dal nostro documento. Nel caso in cui non sia chiaro dalla descrizione, al punto 3 i punti rossi sono suddivisi in punti cremisi e granato. I passaggi 1, 3 e 6 sono tutti tempi lineari. Sappiamo anche che se è il numero totale di punti, | B | ≥ α n , | R | ≥ β n e | C | ≥ γ n per alcuni α , β , γ $n$$|\mathrm{B}| \geq \alpha n$$|\mathrm{R}| \geq \beta n$$|\mathrm{C}| \geq \gamma n$ .$\alpha, \beta, \gamma > 0$

Ti farò capire perché l'intero algoritmo richiede tempo lineare.

1. Suddividere i punti originali nei set blu e rosso B e R.
2. Calcola ricorsivamente lo scafo convesso dei punti blu.
3. Usando la struttura dello scafo blu, selezionare i punti cremisi C.
4. Aggiungi i punti cremisi allo scafo blu uno alla volta.
5. Calcola ricorsivamente lo scafo convesso dei punti granato G.
6. Unisci questo scafo granato con lo scafo blu espanso del passaggio 4.

Ciò che rende lineare l'algoritmo è la possibilità di aggiungere una frazione fissa dei punti rossi allo scafo blu a un costo costante per punto. I punti aggiunti sono i punti cremisi.

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

Esiste una variazione sulla ricorrenza della ricerca mediana che proviene dalla ricerca della distanza con mezzi aerei. La ricorrenza stessa è della forma

$$T(n) = T(n/2) + T(n/4) + cn$$ che è simile alla ricorrenza del ritrovamento mediano. Per ulteriori informazioni, guarda gli appunti di Jeff Erickson e in particolare la Sezione 4.

Ci sono un sacco di fantastici algoritmi ricorsivi [1], [2] usati nella previsione della struttura secondaria dell'RNA. Lasciato a se stesso, un filamento di RNA formerà coppie di basi con se stesso; un esempio relativamente semplice di [3] calcola il numero massimo di basi annidate e accoppiate che una stringa RNA formerà con se stessa:

$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. Piegatura ottimale del computer di grandi sequenze di RNA utilizzando la termodinamica e le informazioni ausiliarie di M. Zuker, P. Stiegler (1981)

2. Un algoritmo di programmazione dinamica per la previsione della struttura dell'RNA, inclusi gli pseudoknots di E. Rivas, SR Eddy (1999)

3. Algoritmo rapido per la previsione della struttura secondaria dell'RNA a singolo filamento di R. Nussinov, AB Jacobson (1980)

Non capisco ancora cosa intendi per "ricorsione sofisticata". Ad esempio, la fase di ricorsione nell'algoritmo FFT è sofisticata!

Ma se vuoi cercare una ricorsione più complicata , la ricorsione reciproca potrebbe essere una possibile risposta. La ricorsione reciproca è utile quando si lavora con linguaggi di programmazione funzionali . La ricorsione reciproca è la caratteristica chiave dei parser di discesa ricorsiva .

Dalla parte superiore della mia testa, la funzione McCarthy 91

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

e la funzione 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

potrebbe essere considerato come insolito, anche se giocattolo, funzioni ricorsive.