Ejemplos de algoritmos recursivos sofisticados

Estaba explicando el famoso algoritmo determinista de selección de tiempo lineal ( algoritmo de mediana de medianas) a un amigo.

La recurrencia en este algoritmo (aunque es muy simple) es bastante sofisticada. Hay dos llamadas recursivas, cada una con diferentes parámetros.

Estaba tratando de encontrar otros ejemplos de algoritmos recursivos tan interesantes, pero no pude encontrar ninguno. Todos los algoritmos recursivos que se me ocurren son simples recursiones de cola o simples divide y vencerás (donde las dos llamadas son "iguales").

¿Puedes dar algunos ejemplos de recurrencia sofisticada?

Mi recurrencia favorita aparece en algoritmos sensibles a la salida para calcular cascos convexos, primero por Kirkpatrick y Seidel , pero luego por otros. Deje denotar el tiempo para calcular el casco convexo de n puntos en el plano, cuando el casco convexo tiene h vértices. (El valor de h no se conoce de antemano, aparte del límite trivial h ≤ n .) El algoritmo de Kirkpatrick y Seidel produce la recurrencia T ( n , h ) = n ≤ 3  o  h $T(n,h)$$n$$h$$h$$h\le n$ donden1,n2≤3n/4yn1+n2=nyh

$$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 solución es . Esto es un poco sorprendente, ya que h no es el parámetro que se divide de manera uniforme. Pero, de hecho, el peor caso de la recurrencia ocurre cuando h 1 y h 2 son ambos acerca de h / 2 ; si de alguna manera mágicamente h 1 es siempre constante, la solución sería 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)$

Utilicé una variante de esta recurrencia en uno de mis primeros trabajos de topología computacional : donde n 1 +

$$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}$$ y g 1 + g 2 = g . Nuevamente, la solución es O ( n log g ) , y elpeor de loscasos ocurre cuando ambos$n_1 + n_2 = n$$g_1 + g_2 = g$$O(n\log g)$$n$ como se dividen siempre de manera uniforme.$g$

La recursión que usé en mi artículo "Un algoritmo de tiempo lineal para calcular el diagrama de Voronoi de un polígono convexo" de Aggarwal et al también es bastante complicada.

Aquí hay una descripción del algoritmo de nuestro artículo. En caso de que no esté claro en la descripción, en el paso 3 los puntos rojos se dividen en puntos carmesí y granate. Los pasos 1, 3 y 6 son todos de tiempo lineal. También sabemos que si es el número total de puntos, | B | ≥ α n , | R | ≥ β n , y | C | ≥ γ n para algunos α , β , γ > 0 .$n$$|\mathrm{B}| \geq \alpha n$$|\mathrm{R}| \geq \beta n$$|\mathrm{C}| \geq \gamma n$$\alpha, \beta, \gamma > 0$

Te dejaré descubrir por qué todo el algoritmo toma tiempo lineal.

1. Divide los puntos originales en los conjuntos azul y rojo B y R.
2. Calcule recursivamente el casco convexo de los puntos azules.
3. Usando la estructura del casco azul, seleccione los puntos carmesí C.
4. Agregue los puntos carmesí al casco azul uno a la vez.
5. Calcule recursivamente el casco convexo de los puntos de granate G.
6. Combina este casco de granate con el casco azul expandido del paso 4.

Lo que hace que el algoritmo sea lineal es la capacidad de agregar una fracción fija de los puntos rojos al casco azul a un costo constante por punto. Los puntos agregados son los puntos carmesí.

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

Existe una variación en la mediana de recurrencia de hallazgos que proviene de la búsqueda de rango con medios planos. La recurrencia misma es de la forma

$$T(n) = T(n/2) + T(n/4) + cn$$ que es similar a la recurrencia de búsqueda media. Para obtener más información al respecto, consulte las notas de clase de Jeff Erickson y, en particular, la Sección 4.

Hay un montón de algoritmos recursivos geniales [1], [2] utilizados en la predicción de la estructura secundaria de ARN. Dejado a sus propios dispositivos, una cadena de ARN formará pares de bases consigo mismo; un ejemplo relativamente simple de [3] calcula el número máximo de bases anidadas y emparejadas que se formará una cadena de ARN consigo misma:

$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. Plegado óptimo por computadora de grandes secuencias de ARN utilizando termodinámica e información auxiliar por M. Zuker, P. Stiegler (1981)

2. Algoritmo de programación dinámica para la predicción de la estructura de ARN que incluye pseudonudos por E. Rivas, SR Eddy (1999)

3. Algoritmo rápido para predecir la estructura secundaria del ARN monocatenario por R. Nussinov, AB Jacobson (1980)

Todavía no entiendo lo que quieres decir con "recursión sofisticada". Por ejemplo, el paso de recursión en el algoritmo FFT es sofisticado.

Pero si desea buscar una recursión más complicada , entonces la recursividad mutua podría ser una posible respuesta. La recursividad mutua es útil cuando se trabaja con lenguajes de programación funcionales . La recursividad mutua es la característica clave de los analizadores de descenso recursivo .

Fuera de mi cabeza, la función McCarthy 91

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

y la función de 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

podría contar como funciones recursivas poco convencionales, aunque juguetonas.