Partie 2 Construction d’algorithmes

(1)

Partie 2

Construction d’algorithmes

24 septembre 2019

(2)

Plan

1.Introduction

2.Construction d’algorithmes it´eratifs 3.Construction d’algorithmes r´ecursifs

Construction d’algorithmes 49

(3)

Construction de programme

Pour résoudre un problème de programmation complexe, on le découpe généralement ensous-problèmesplus simples à appréhender

Exemples de sous-probl`emes pour afficher l’ensemble de Mandelbrot : I SP1 : calculer le module d’un nombre complexe,

I SP2 : v´erifier l’appartenance d’un point `a l’ensemble, I SP3 : produire l’image en parcourant le plan complexe.

Ces problèmes dépendent généralement les uns des autres.

Dans l’exemple, SP3 d´epend de SP2 qui d´epend de SP1.

Avantages d’un d´ecoupage :

Facilite l’implémentation : on peut résoudre chaque sous-problème indépendamment,

Généralité : on peut partager du code entre di↵érents programmes,

(4)

Construction de programmes

Résoudre un sous-problème élémentaire :

Certains sont triviaux et requièrent d’établir une séquence simple d’instructions (p.ex., calculer le module d’un nombre complexe) D’autres sont plus complexes et nécessitent derépéter une séquence d’instructions selon un schéma dépendant des données(p.ex., déterminer l’appartenance à l’ensemble de Mandelbrot)

Deux grands types de solutions algorithmiques pour ces derniers cas : Solutions it´eratives, bas´ees sur des boucles

Solutions récursives, basées sur des fonctions qui s’invoquent elles-mêmes

On va (re)voir dans cette partie quelques grands principes pour la conception de ces deux types de solutions.

(5)

Plan

1.Introduction

2.Construction d’algorithmes it´eratifs Technique de l’invariant

Illustrations

Correction d’algorithmes it´eratifs 3.Construction d’algorithmes r´ecursifs

(6)

Construction d’algorithmes it´eratifs

Concevoir un algorithme itératif (correct) peut être un exercice très compliqué, surtout si on cherche une solution efficace.

Deux difficult´es principales :

Imaginer le schéma itératifpermettant de résoudre le problème.

Générer lecode implémentant ce schéma en évitant les bugs.

Le premier problème est de loin le plus compliqué et cette compétence s’acquière quasi uniquement via la pratique (cf. INFO0902 pour des techniques génériques néanmoins).

Latechnique de l’invariantpermet d’aborder formellement le second problème une fois le schéma de la boucle imaginé.

(7)

Invariant de boucle

Uninvariant de boucle est une propriété définie sur les variables du programme qui définit précisément ce qui doit être calculé à chaque itération pour arriver au résultat escompté. Il résume l’état courant des calculs.

Identifier l’invariant revient à imaginer le schéma itératif de résolution du problème et est parfois non trivial.

Une fois l’invariant établi, implémenter la boucle peut par contre se faire de manière relativement automatique.

L’utilisation de l’invariant permet donc d’´eviter les erreurs d’impl´ementation.

(8)

Invariant de boucle

Une assertionest une relation entre les variables et les données utilisées par le programme qui est vraie à un moment donné lors de l’exécution du programme.

Deux assertions particuli`eres :

Pr´e-condition P :condition que doivent remplir les entr´ees valides du programme

Post-conditionQ :condition qui exprime que le r´esultat du programme est celui attendu.

On cherche donc à écrire un programme, notéS, dont l’exécution dans tous les cas où P est vraie mène à ce queQ soit toujours vraie.

Lorsque c’est le cas, on dira que le triplet{P}S{Q} est correct.

Exemple : SiP ={x 0} etQ ={y² =x}, le code S = ”y = sqrt(x); ” rend le triplet {P}S{Q}correct.

(9)

Invariant de boucle : plus formellement

{P} INIT while(B)

CORPS FIN

{Q}

{P} INIT {I} while(B)

{I etB}CORPS{I} {I et nonB}

FIN {Q}

Dans le cas o`u le programme n´ecessite une boucle :

On met en évidence une assertion particulière I,l’invariant de boucle, qui décrit l’état du programme pendant la boucle.

On d´etermine ensuite le gardien B et les codes INIT,CORPS et FIN tels que les trois triplets suivants soient corrects :

I {P}INIT{I} I {I etB}CORPS{I} I {I et nonB} FIN{Q}

(10)

Ecriture du code sur base de l’invariant

Trois parties de code `a ´ecrire en se basant sur l’invariant: 1. Initialisation :{P} INIT{I}

I INIT doit rendre l’invariant vrai avant de rentrer dans la boucle et en partant de la pr´e-condition.

I L’invariant identifie les variables n´ecessaires et comment les initialiser.

2. Maintenance :{I etB}CORPS{I}

I CORPS doit faireavancerle probl`eme en maintenant l’invariant en supposant que le gardien soit vrai.

I L’invariant d´efinit le sch´ema de la boucle.

3. Terminaison :{I et non B} FIN{Q}

I FIN doit rendre la post-condition vraie en supposant que l’invariant est v´erifi´e et le gardien est faux.

I L’invariant définit comment finalement résoudre le problème.

(11)

D´etermination de l’invariant

Pas de recette miracle pour d´eterminer l’invariant (ou de mani`ere

´equivalente le sch´ema d’une boucle).

Quelques trucs n´eanmoins :

Enlever une partie de la post-condition

Remplacer dans la post-condition une constante par une variable Combiner les pr´e-conditions et post-conditions

Raisonner par induction (voir plus loin)

Dans tous les cas, l’invariant doit faire apparaˆıtre toutes les variables du programme.

Pour un même problème, plusieurs invariants (et/ou gardiens de boucles) sont possibles qui mèneront à di↵érentes implémentations de la boucle.

(12)

Illustration 1 : appartenance `a l’ensemble de Mandelbrot

Pr´e et post-conditions : P ={cr2R,ci2R}

Q ={r= 1 si 8n,0nN:|zn|2,0 sinon}

où cr et ci sont les entrées du programme, r le résultat, N une constante, etzn est lan-ème valeur de la suite définie précédemment avec c 2C tel quec =cr+ici.

Sch´ema de la boucle :

On calculezn pour des valeurs croissantes de n allant de 0 `aN.

A chaque itération, on calculezn à partir de la valeurzn 1 calculée

à l’itération précédente.

On s’arrˆete d`es que|zn|>2.

(13)

Illustration 1 : appartenance `a l’ensemble de Mandelbrot

Invariant :

I ={(8n⁰: 0n⁰<n:|z_n0|2) et (zr+izi=z_n) et (0nN)}, oùnest le compteur de boucle etzretzisont deux variables qui contiendront les résultats intermédiaires.

|···|2

z }| {

z₀,z₁, . . . ,z_n ₁,

|···|?

z z_n }| {

|{z}

zr+izi=zn

,z_n+1, . . . ,z_N

Gardien :

B={n<N,zr²+zi²4}.

(14)

Illustration 1 : appartenance `a l’ensemble de Mandelbrot

|···|2

z }| {

z0,z1, . . . ,zn 1,

|···|?

z }| {

zn

|{z}

zr+izi=zn

,zn+1, . . . ,z_N

{P} {cr2R,ci2R}

INIT {I}

while((n < N) && (zr*zr + zi*zi <= 4.0)) { {IetB}

CORPS {I} }

{Iet nonB} FIN

{Q} {r= 1 si9n: 0nN:|zn|>2,0 sinon}

(15)

Illustration 1 : appartenance `a l’ensemble de Mandelbrot

|···|2

z }| {

z0,z1, . . . ,zn 1,

|···|?

z }| {

zn

|{z}

zr+izi=z_n

,zn+1, . . . ,zN

{P} {cr2R,ci2R}

double zr = 0;

double zi = 0;

int n = 0;

{I}

CORPS {I} }

{Iet nonB} FIN

{Q} {r= 1 si9n: 0nN:|zn|>2,0 sinon}

(16)

Illustration 1 : appartenance `a l’ensemble de Mandelbrot

|···|2

z }| {

z0,z1, . . . ,zn 1,

|···|?

z }| {

zn

|{z}

zr+izi=zn

,zn+1, . . . ,z_N

{P} {cr2R,ci2R}

double zr = 0;

double zi = 0;

int n = 0;

{I}

double temp;

temp = zr*zr - zi*zi + cr;

zi = 2*zr*zi + ci;

zr = temp;

n++;

{I} }

{Iet nonB} FIN

{Q} {r= 1 si9n: 0nN:|zn|>2,0 sinon}

(17)

Illustration 1 : appartenance `a l’ensemble de Mandelbrot

|···|2

z }| {

z0,z1, . . . ,zn 1,

|···|?

z }| {

zn

|{z}

zr+izi=zn

,zn+1, . . . ,z_N

{P} {cr2R,ci2R}

double zr = 0;

double zi = 0;

int n = 0;

{I}

double temp;

zi = 2*zr*zi + ci;

zr = temp;

n++;

{I}

}

{Iet nonB}

(18)

Illustration 1 : appartenance `a l’ensemble de Mandelbrot

double zr = 0;

double zi = 0;

int n = 0;

while((n < N) && (zr*zr + zi*zi <= 4.0)) { double temp;

zi = 2*zr*zi + ci;

zr = temp;

n++;

}

int r = (zr*zr+zi*zi <= 4.0);

(19)

Illustration 2 : tri par insertion

On souhaite écrire une fonction pour trier un tableau Ade valeurs entières. Le tri doit être e↵ectué dans le tableau lui-même, via échanges d’éléments.

void insertion_sort(int A[], int N);

Principe de l’algorithme :

On parcourt le tableau de gauche `a droite en triant successivement les pr´efixes du tableau de tailles 2, 3, . . .,N.

A chaque itération, on augmente la taille du préfixe trié en insérant le nouvel élémentA[i] à sa position dans le sous-tableau A[0. .i 1]

précédemment ordonné.

(20)

Tri par insertion : graphiquement

Intro to Data Structures and Algorithms © Introduction, Slide 11

Insertion Sort

5 2 4 6 1 3

2 5 4 6 1 3

2 4 5 6 1 3

1 2 4 5 6 3

1 2 3 4 5 6

(21)

Tri par insertion : boucle externe

Pr´e-condition Pe :A est un tableau d’entiers de tailleN.

Post-conditionQe :Acontient les éléments du tableau de départ triés par ordre croissant.

InvariantIe (de la boucle externe) : Le sous-tableauA[0. .i 1], avec 1i N, contient les i premiers éléments du tableau initial triés par ordre croissant.

trié pas trié

Gardien Be :i <N.

(22)

Tri par insertion : boucle externe

{P_e} {Aest un tableau d’entiers de tailleN}

INITe

{Ie} {A[0. .i 1] tri´e}

while (i<N) {

{I_e etB_e} {A[0. .i 1] tri´e eti <N}

CORPSe

{I_e} {A[0. .i 1] tri´e}

}

{Ie et nonB} {A[0. .i 1] tri´e eti =N}

FINe

{Q_e} {Acontient les éléments du tableau de départ triés}

(23)

Tri par insertion : boucle externe

int i = 1;

{I_e} {A[0. .i 1] tri´e}

while (i<N) {

{Ie etBe} {A[0. .i 1] tri´e eti <N}

CORPSe

{I_e} {A[0. .i 1] tri´e}

}

{Ie et nonB} {A[0. .i 1] tri´e eti =N}

FINe

{Qe} {Acontient les éléments du tableau de départ triés}

(24)

Tri par insertion : boucle externe

{Pe} {Aest un tableau d’entiers de tailleN}

int i = 1;

{Ie} {A[0. .i 1] tri´e}

while (i<N) {

{I_e etB_e} {A[0. .i 1] tri´e eti <N}

CORPSe

{I_e} {A[0. .i 1] tri´e}

}

{I_e et nonB} {A[0. .i 1] tri´e eti =N}

-

{Q_e} {Acontient les éléments du tableau de départ triés}

(25)

Tri par insertion : boucle externe

int i = 1;

{I_e} {A[0. .i 1] tri´e}

while (i<N) {

{Ie etBe} {A[0. .i 1] tri´e eti <N}

CORPSe’

{Qi} {A[0. .i] tri´e}

i++;

{Ie} {A[0. .i 1] tri´e}

}

{I_e et nonB} {A[0. .i 1] tri´e eti =N}

-

{Qe} {Acontient les éléments du tableau de départ triés}

(26)

Tri par insertion : boucle interne (CORPSe’)

Pré-conditionP_i :{I_e etB_e}={A[0. .i 1] trié eti <N} Post-conditionQ_i :I_e ={A[0. .i] trié}

Idée de la boucle :Soitkey =A[i], la valeur à déplacer :

On parcourt le sous-tableauA[0. .i 1] de droite `a gauche.

Tant que les éléments parcourus sont supérieurs àkey, on les décale d’une position vers la droite.

On ins´erekey `a la position finalement atteinte.

(27)

Tri par insertion : boucle interne

InvariantIi :Soit j un nouvel indice etkey =A[i] la valeur à insérer : A[0..j 1] etA[j + 1. .i] sont triés par ordre croissant et ensemble contiennent tous les éléments du sous-tableauA[0. .i] initial, exceptékey.

key <A[j+ 1]

Gardien Bi :{j >0 etA[j 1]>key}

(28)

Tri par insertion : boucle interne

{Pi} {A[0. .i 1] tri´e eti <N}

INITi {I_i}

while (j > 0 && A[j-1] > key) { {I_i etB_i}

CORPSi {Ii} }

{I_i et nonB_i} FINi

{Q_i} {A[0. .i 1] tri´e}

(29)

Tri par insertion : boucle interne

{Pi} {A[0. .i 1] tri´e eti <N}

int key = A[i];

int j = i;

{I_i}

CORPSi {I_i} }

{Ii et nonBi} FINi

{Qi} {A[0. .i 1] tri´e}

(30)

Tri par insertion : boucle interne

{P_i} {A[0. .i 1] tri´e eti <N}

int key = A[i];

int j = i;

{I_i}

A[j] = A[j-1];

j--;

{Ii} }

{I_i et nonB_i} FINi

{Q_i} {A[0. .i 1] tri´e}

(31)

Tri par insertion : boucle interne

{P_i} {A[0. .i 1] tri´e eti <N}

int key = A[i];

int j = i;

{Ii}

while (j > 0 && A[j-1] > key) { {Ii etBi}

A[j] = A[j-1];

j--;

{I_i} }

{I_i et nonB_i} A[j] = key;

i++;

(32)

Tri par insertion : code complet

void insertion_sort(int A[], int N) { int i = 1;

while (i < N) { int key = A[i];

int j = i;

while (j > 0 && A[j-1]>key) { A[j] = A[j-1];

j--;

}

A[j] = key;

i++;

} }

(33)

Synth`ese

L’expression d’un invariant permet de limiter les erreurs lors de l’impl´ementation d’une boucle.

Vous devez prendre l’habitude d’exprimer l’invariant de toutes vos boucles avantleur impl´ementation, au minimum de mani`ere informelle ou graphique.

Dans la suite du cours, on fournira ponctuellement les invariants des boucles les plus compliqu´ees.

(34)

Plan

1.Introduction

Illustrations

(35)

Preuve de correction d’algorithmes it´eratifs

Dans certains contextes, il est crucial de prouver formellement qu’un programme est correct (p.ex. dans le domaine m´edical ou en

a´eronautique).

On peut toujours tester son programmeempiriquementmais en général, il est impossible de considérer tous les cas possibles d’utilisation d’un code.

Testing can only show the presence of bugs, not their absence E.W. Dijkstra L’analyse de correction de triplets et la technique de l’invariant de boucle peuvent aussi être utilisées pour prouver formellement qu’un algorithme itératif est correct (voir INFO2009).

On peut automatiser une grosse partie de ces analyses, mais pas la d´erivation des invariants de boucle.

(36)

Terminaison de boucle

Prouver qu’un triplet{P}S{Q} est correct n’est pas suffisant dans le cas d’une boucle.

Il faut encore prouver que la boucle se termine.

Exemple : On peut prouver que le triplet ci-dessous est correct mais la boucle ne se termine pas toujours. On dira que le code estpartiellement correct.

{cr2R,ci2R}

double zr = 0;

double zi = 0;

while(zr*zr + zi*zi <= 4.0)) { double temp;

zi = 2*zr*zi + ci;

zr = temp;

}

int r = (zr*zr+zi*zi <= 4.0);

{r= 1 si8n 0 :|zn|2,0 sinon}

(37)

Terminaison de boucle

Pour prouver qu’une boucle se termine, on cherche une fonction de terminaison f :

définie sur base des variables de l’algorithme et à valeur entière naturelle( 0)

telle quef décroˆıt strictement suite à l’exécution du corps de la boucle

telle queB implique f >0

Puisque f d´ecroit strictement, elle finira par atteindre 0 et donc `a infirmerB.

Exemple :

Mandelbrot :f =N n

Tri par insertion (boucle externe) :f =N i

(38)

Terminaison de boucle

Il n’est pas toujours trivial de prouver la terminaison d’une boucle.

Personne n’a pu encore prouv´e que la boucle suivante se terminait pour tout n>1, bien qu’on l’ait prouv´e empiriquement pour toutes les valeurs deN <1,25.2⁶².

void Algo(int n) { while(n != 1) {

if (n % 2) // n est impair n = 3*n+1;

else // n est pair n = n/2;

} }

https://fr.wikipedia.org/wiki/Conjecture_de_Syracuse

(39)

Plan

1.Introduction

Principe Illustrations

Implémentation de la récursivité

(40)

Algorithme r´ecursif

Unalgorithmede résolution d’un problème P sur une donnéeaest dit récursif si parmi les opérations utilisées pour le résoudre, on trouve une résolution du même problèmeP sur une donnéeb.

Dans un algorithme récursif, on nommera appel récursiftoute étape résolvant le même problème sur une autre donnée.

Un algorithme récursif s’implémente généralement via desfonctions récursives.

Forme générale d’une fonction récursive (directe) : type f(P) {

...

x = f(Pr);

...

return r;

}

(41)

Exemple 1 : fonction factorielle

La définition mathématique de la factorielle est récursive : n! =

(1 si n1,

n⇤(n 1)! sinon

et se prête donc naturellement à une implémentation via une fonction récursive :

int fact(int n) { if (n <= 1)

return 1;

return n * fact(n-1);

}

(42)

Exemple 1 : fonction factorielle

Trace des appels de fonctions pour fact(5) : fact(5)

|fact(4)

| |fact(3)

| | |fact(2)

| | | |fact(1)

| | | |return 2*1 = 2

| | |return 3*2 = 6

| |return 4*6 = 24

|return 5*24 = 120

(43)

Exemple 2 : algorithme d’Euclide

L’algorithme du calcul du pgcd d’Euclide est basé sur la propriété récursive suivante :

Soient deux entiers positifs a et b. Sia > b, le pgcd de a et b est ´egal au pgcd deb et de (a modb).

Suggère l’implémentation récursive suivante :

int pgcd(int a, int b) { if (b > a)

return pgcd(b,a);

if (b == 0) return a;

return pgcd(b, a % b);

}

Exemple :

pgcd(1440, 408)

|pgcd(408, 216)

| |pgcd(216, 192)

| | |pgcd(192, 24)

| | | |pgcd(24,0)

| | | |return 24

| | |return 24

(44)

Conception de fonctions r´ecursives

Deux conditions pour qu’une fonction récursive soit bien définie : Présence d’un cas de base(condition d’arrêt)

La “taille” du problème doit être réduiteà chaque étape Forme générale d’une fonction récursive :

type f(P) {

if (cas_de_base) { // cas de base ... // pas d'appel r´ecursif return [...];

}

// ´etape de r´eduction ...

[x =] f(Pr); // avec Pr plus "simple" que P ...

[return r;]

}

(45)

Conception de fonctions r´ecursives

D’autres formes peuvent néanmoins être valides (mais sont plutôt à éviter).

Récursivité non décroissante

(Suite de Syracuse)

intSyracuse(int n) { if(n==1)

return1;

if(n%2)// n est impair returnSyracuse(3*n+1);

else // n est pair returnSyracuse(N/2);

}

Récursivité imbriquée

(fonction d’Ackermann)

intack(intm,intn) { if(m==0)

returnn+1;

else{ if(n==0)

returnack(m-1,1);

else

returnack(m-1,ack(m,n-1));

} }

Récursivité croisée

intP(intn) { if(n==0)

return1;

else

returnI(n-1);

}

intI(intn) { if(n==0)

return0;

Que calcule la fonctionP?

(46)

Principe de construction d’un algorithme r´ecursif

Trouver un ou plusieurs param`etres de taillesur lesquels construire la r´ecursion

Factorielle :n, le nombre dont on veut calculer la factorielle.

Trouver une solution pour le(s) cas de base, c’est-`a-dire des probl`emes de petites tailles (la plupart du temps trivial).

Factorielle :n! = 1 sin1.

Trouver commentréduirele problème à un ou plusieurs sous-problème de tailles strictement plus petites.

Factorielle :n! =n⇤(n 1)! si n>1

La dernière étape est la plus délicate. Equivalent à trouver l’invariant dans le cas d’algorithmes itératifs.

(47)

Plan

1.Introduction

(48)

Fonction puissance : solution it´erative

On souhaite calculer a^x, aveca2Ret x entier 1.

Version it´erative

float pow_iter(float a, int x) { float res = a;

for (int i = 1; i < x; i++) res = res * a;

return res;

}

(Invariant ?) Nombre de multiplications n´ecessaires :x 1

(49)

Fonction puissance : r´ecursivement

^(1/2)

Une premi`ere formulation r´ecursive : a^x =

(a si x = 1

a·a^x ¹ si x >1

float pow_rec1(float a, int x) { if (x == 1)

return a;

return a*pow_rec1(a, x-1);

}

Nombre de multiplications n´ecessaires :x 1

Cette version est une simple réécriture de la version itérative.

(50)

Fonction puissance : r´ecursivement

^(2/2)

Une deuxi`eme formulation r´ecursive :

a^x = 8>

<

>:

a si x= 1

(a·a)^x/2 si x>1 et pair a·(a·a)^(x ^1)/2 si x>1 et impair

float pow_rec2(float a, int x) { if (x == 1)

return a;

if (x % 2 == 0) // x pair return pow_rec2(a * a, x/2);

else // x impair

return a * pow_rec2(a * a, (x-1)/2);

}

Nombre de multiplications n´ecessaires : entre log₂(x) et 2 log₂(x) x = 128) 7 multiplications au lieu de 127.

(51)

Fonction puissance : remarque

La solution précédente peut aussi s’implémenter de manière itérative.

Mais l’invariant de la boucle est obtenu sur base de la même formulation récursive et l’implémentation serait (un peu) moins immédiate.

Il existe des problèmes pour lesquels une solution itérative serait nettement plus complexe à implémenter qu’une solution récursive.

(52)

Le probl`eme des tours de Hano¨ı

cf. INFO2009

Source : wikipedia

Objectif : transf´erer lesndisques de la tour 1 `a la tour 2, sans jamais mettre un disque sur un plus petit.

Solution r´ecursive :Pour d´eplacerndisques:

On d´eplace lesn 1 disques du dessus vers la tour 3.

On d´eplace len-`eme disque de la tour 1 vers la tour 2.

On d´eplace lesn 1 disques de la tour 3 vers la tour 2.

Solution it´erative?

(53)

Le probl`eme des tours de Hano¨ı

cf. INFO2009

Source : wikipedia

En fait, une solution it´erative simple existe :

Tant que la pile n’est pas dans sa position finale :

Bouger le plus petit disque à droite (1!2,2!3 ou3!1) Bouger le seul autre disque qui peut être bougé

Cette solution bien que strictement identique à la solution récursive est beaucoup plus compliquée à concevoir à partir de rien.

Son impl´ementation est aussi plus complexe car elle demande de repr´esenter

(54)

Percolation

(Sedgewick et Wayne, 2016)

Problème : déterminer si de l’eau peut s’écouler dans un matériau poreux.

Entrée : un tableaugrid de taillen⇥n, tel quegrid[i][j] = 0 si le matériau est vide à la position (i,j), 1 si le matériau est plein.

Sortie : vrai s’il existe un chemin partant de la première ligne, arrivant à la dernière ligne de la matrice et passant uniquement par des cases vides, faux sinon.

(55)

Percolation : d´ecoupage en sous-probl`eme

Id´ee de la solution :

Marquer chaque case de la grille pour laquelle il existe un chemin depuis une case vide de la premi`ere ligne.

Vérifier qu’une case de la dernière ligne au moins a été marquée.

// Valeur 2 utilis´ee comme marquage int percolate(int **grid, int n) {

flow(grid,n); // fonction qui effectue le marquage des cases for (int j = 0; j < n; j++)

if (grid[n-1][j] == 2) return 1;

return 0;

}

(56)

Fonction flow : d´ecoupage en sous-probl`emes

On d´efinit une fonction flowrec:

void flowrec(int **M, int **marked, int N, int i, int j);

qui va marquer toutes les cases accessibles `a partir de la position (i,j).

La fonction flowconsiste alors simplement à appliquer flowrecà toutes les cases de la première ligne du tableau.

void flow(int **grid, int n) { for (int j = 0; j < n; j++)

flowrec(grid, n, 0, j);

}

(57)

Une solution r´ecursive pour flowrec

void flowrec(int **grid, int n, int i, int j);

Cas de base : Ne rien faire si i<0, i n,j<0, ouj n, (la case est hors de la grille) grid[i][j] == 1,

(la case est pleine) grid[i][j] == 2

(la case a déjà été visitée lors d’un précédent appel récursif).

Cas inductif : Si on est pas dans un cas de base : On marque la case (i,j) qui est accessible.

On applique récursivement la fonctionflowrec à toutes les cases adjacentes à la case (i,j).

(58)

Une solution r´ecursive pour flowrec

void flow(int **grid, int n) { for (int j = 0; j < n; j++)

flowrec(grid, n, 0, j);

}

void flowrec(int **grid, int n, int i, int j) { // Cas de base

if (i < 0 || i >= n || j < 0 || j >= n) return;

if (grid[i][j] == 1 || grid[i][j]== 2) return;

// Cas inductif grid[i][j] = 2;

flowrec(grid, n, i+1, j); // Bas flowrec(grid, n, i, j+1); // Droite flowrec(grid, n, i, j-1); // Gauche flowrec(grid, n, i-1, j); // Haut }

Correction ? Complexit´e ?

Note :flowrecimpl´emente ce qu’on appelle une recherche en profondeur d’abord (depth-first search).

(59)

Illustration

(60)

Application : simulations num´eriques

Cette fonction permet par exemple d’étudier l’impact de la porosité du matériau sur la probabilité de percolation.

Pour des grilles de taille 100x100 (10000 grilles aléatoires générées par point) :

(Sedgewick et Wayne, 2016)

(61)

Efficacit´e de codes r´ecursifs

Dans le cas de la fonction puissance, des tours de Hano¨ı et de la percolation, la solution r´ecursive donne un code optimal en terme de complexit´e.

Dans certains cas, l’utilisation na¨ıve de la récursivité peut cependant mener à une solution très sous-optimale.

Exemple : calcul des nombres de Fibonacci F0 = 0 F1 = 1

8n 2 :Fn = Fn 2+Fn 1

(62)

Nombres de Fibonacci : impl´ementation r´ecursive

Impl´ementation r´ecursive directe : int Fib(int n) {

if (n <= 1) return n;

return Fib(n-1)+Fib(n-2);

}

Peut-on calculerFib(60) ?

n temps de calcul

10 0s

20 0s

40 1s

45 8s

50 87s

60 ? ?

(63)

Nombres de Fibonacci : arbres des appels r´ecursifs

0

0 0

0

0 1 1

1 1 1

1 1

1

1 1

2 1 2

2

3

5

8

3

Beaucoup de valeurs sont recalcul´ees inutilement.

(64)

Nombres de Fibonacci : temps de calcul

Soit T(n) le nombre de noeuds de l’arbre des appels r´ecursifs. On a : T(0) = 1

T(1) = 1

8n 2 :T(n) = T(n 1) +T(n 2) + 1

Le nombre d’appels de fonctions est donc plus élevé que lenème nombre de Fibonacci qui vaut approximativement ^pⁿ

5, avec ⇡1,618.

Chaque appel de fonction demandant un temps constant, les temps de calcul vont augmenterexponentiellement avecn. Ils sont multipliés par 1,618 au moins à chaque incrément den.

S’il faut 87s pour n= 50, il faudra au moins 3 heures pourn = 60 et

>77000 ann´ees pourn= 100.

(65)

Nombres de Fibonacci : version it´erative

Une version it´erative beaucoup plus efficace

int Fibiter(int n) { if (n <= 1)

return n;

else { int f;

int pprev = 0;

int prev = 1;

for (int i = 2; i <= n; i++) { f = prev + pprev;

pprev = prev;

prev = f;

}

return f;

} }

n R´ecursive It´erative

10 0s 0s

20 0s 0s

40 1s 0s

45 8s 0s

50 87s 0s

60 3h 0,001s

100 77k ans 0,001s

(66)

Correction formelle d’algorithmes r´ecursifs

int fact(int n) { if (n <= 1)

return 1;

return n * fact(n-1);

}

La correction d’un algorithme r´ecursif se prouve pas induction: On montre que le code est correct dans lecas de base.

I Sin1,fact(n) renvoie 1, ce qui est correct.

On montre que l’étape de réduction est correcte en supposant que les appels récursifs sont corrects (hypothèse inductive)

I Sin>1, la fonction renvoien⇤fact(n 1), qui vaut bienn! si fact(n-1)renvoie (n 1)!.

On en conclut, par leprincipe d’induction, que l’algorithme est correct pour toutes les entr´ees.

(67)

Plan

1.Introduction

Illustrations

(68)

Une exp´erience

Y-a-t’il une di↵´erence lors de l’ex´ecution de ces deux codes ?

int fact_rec(int n) { return n*fact_rec(n-1);

}

int main() { fact_rec(100);

return 0;

}

int fact_iter(int n) { int res = 1;

for (;; n--) res = res*n;

return res;

}

int main() { fact_iter(100);

return 0;

}

(69)

Contextes d’appels de fonctions

A chaque appel de fonction, on doit retenir en mémoire (dans une zone appelée leStack) le contexte de l’appel, c’est-à-dire :

L’endroit où le code appelant doit continuer son exécution à la fin de l’appel

La valeur des argumentsfournis `a la fonction La valeur des variables locales`a la fonction

Cette information ne peut être suppriméequ’une fois l’appel terminé.

Dans le cas d’une fonction récursive, le nombre d’appels de fonction actifs à un moment donné peut être très important.

La récursivité a donc uncoût mémoiredont il faut tenir compte.

Ce coût mémoire est directement proportionnel à laprofondeur de l’arbre

(70)

Contextes d’appels de fonctions : illustration

int fact(int n) { if (n == 1)

return 1;

return n*fact(n-1);

}

int main() { fact(5);

return 0;

}

(71)

Une exp´erience : conclusion

Y-a-t’il une di↵´erence lors de l’ex´ecution de ces deux codes ? int fact_rec(int n) {

return n*fact_rec(n-1);

}

int main() { fact_rec(100);

return 0;

}

)Le programme s’arrête lorsque la mémoire qui lui est allouée est remplie.

int fact_iter(int n) { int res = 1;

for (;; n--) res = res*n;

}

int main() { fact_iter(100);

return 0;

}

) Le programme ne s’arrˆete jamais.

(72)

R´ecursivit´e terminale

Une fonction estrécursive terminale s’il n’y a plus de calcul à e↵ectuer une fois l’appel récursif terminé.

Exemple : le calcul du PGCD :

int pgcd(int a, int b) { if (b > a)

return pgcd(b,a);

if (b == 0) return a;

return pgcd(b, a % b);

}

Il est dans ce cas inutile de stocker le contexte des appels.

Les compilateurs modernes sont capables de détecter ce type de récursion (et d’autres plus compliquées) et de ne pas utiliser de mémoire inutile.

(73)

Synth`ese

Principal intérêt de la récursivité : élegance, simplicité, et lisibilité du code.

Moins sujet `a des bugs et analyse de correction facilit´ee par rapport aux boucles.

Beaucoup d’algorithmes efficaces sont basés sur la récursivité (cf.

Partie 5 et INFO0902).

Mais l’utilisation na¨ıve de la récursivité peut parfois mener à des solutions moins efficaces, voire très inefficaces.

Il existe néanmoins des techniques systématiques pour améliorer l’efficacité d’une solution récursive (cf. INFO0902 et INFO0540).

L’implémentation a souvent un coût non négligeable en terme d’espace mémoire dont il faut tenir compte.