Exemples d'algorithmes récursifs sophistiqués

J'expliquais à un ami le célèbre algorithme de sélection déterministe du temps linéaire ( algorithme de la médiane des médianes).

La récursivité dans cet algorithme (tout en étant très simple) est assez sophistiquée. Il existe deux appels récursifs, chacun avec des paramètres différents.

J'essayais de trouver d'autres exemples d'algorithmes récursifs aussi intéressants, mais je n'en ai trouvé aucun. Tous les algorithmes récursifs que je pourrais proposer sont soit de simples récursions de queue, soit de simples divisions et conquêtes (où les deux appels sont "les mêmes").

Pouvez-vous donner quelques exemples de récursivité sophistiquée?

Ma récurrence préférée apparaît dans les algorithmes sensibles à la sortie pour le calcul des coques convexes, d'abord par Kirkpatrick et Seidel , mais répétés plus tard par d'autres. Soit n ≤ 3  ou  h ≤ 3 T ( n 1 , h 1 ) + T ( n 2 , h 2 ) + O ( n ) sinon où n 1$T(n,h)$ le temps de calculer la coque convexe de points dans le plan, lorsque la coque convexe a h sommets. (La valeur de h n'est pas connue à l'avance, à part la borne triviale h ≤ n .) L'algorithme de Kirkpatrick et Seidel donne la récurrence T ( n , h ) = { O ( n ) $n$$h$$h$$h\le n$

$$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}$$ et n 1 + n 2 = n et h 1 + h 2 = h .$n_1, n_2 \le 3n/4$$n_1 + n_2 = n$$h_1 + h_2 = h$

$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}$$ $n_1 + n_2 = n$$g_1 + g_2 = g$$O(n\log g)$$n$$g$

La récursion que j'ai utilisée dans mon article "Un algorithme à temps linéaire pour calculer le diagramme de Voronoï d'un polygone convexe" par Aggarwal et al est également assez compliquée.

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

Je vous laisse comprendre pourquoi tout l'algorithme prend du temps linéaire.

1. Partitionnez les points d'origine dans les ensembles bleu et rouge B et R.
2. Calculer récursivement la coque convexe des points bleus.
3. En utilisant la structure de la coque bleue, sélectionnez les points cramoisis C.
4. Ajoutez les points cramoisis à la coque bleue un par un.
5. Calculer récursivement la coque convexe des points grenat G.
6. Fusionnez cette coque grenat avec la coque bleue expansée de l'étape 4.

Ce qui rend l'algorithme linéaire, c'est la possibilité d'ajouter une fraction fixe des points rouges à la coque bleue à un coût par point constant. Les points ajoutés sont les points cramoisis.

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

Il y a une variation sur la récurrence médiane de la découverte qui provient de la recherche de distance avec des demi-plans. La récurrence elle-même est de la forme

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

Il existe un tas d'algorithmes récursifs sympas [1], [2] utilisés dans la prédiction de la structure secondaire de l'ARN. Laissé à lui-même, un brin d'ARN formera des paires de bases avec lui-même; un exemple relativement simple de [3] calcule le nombre maximum de bases appariées imbriquées qu'une chaîne d'ARN formera avec elle-même:

$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. Pliage informatique optimal de grandes séquences d'ARN en utilisant la thermodynamique et les informations auxiliaires par M. Zuker, P. Stiegler (1981)

2. Un algorithme de programmation dynamique pour la prédiction de la structure de l'ARN incluant les pseudoknots par E. Rivas, SR Eddy (1999)

3. Algorithme rapide pour prédire la structure secondaire de l'ARN simple brin par R. Nussinov, AB Jacobson (1980)

Je ne comprends toujours pas vraiment ce que vous entendez par "récursion sophistiquée". Par exemple, l'étape de récursivité dans l'algorithme FFT est sophistiquée!

Mais si vous souhaitez rechercher une récursivité plus compliquée , la récurrence mutuelle pourrait être une réponse possible. La récursion mutuelle est utile lorsque vous travaillez avec des langages de programmation fonctionnels . La récursion mutuelle est la caractéristique clé des analyseurs de descente récursifs .

Du haut de ma tête, la fonction McCarthy 91

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

et la fonction 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

pourraient compter comme des fonctions récursives décalées, bien que trop amusantes.