Correction Examen Algorithmique

// Les algorithmes ci-dessous est ne sont qu’une solution proposée par un étudiant, elles
sont peut-être fausses et il existe surement des solutions plus robustes et optimisées.

Exercice 1 :
// Il est demandé de trouver la plus longue sous séquence communes entre deux listes. On
va traiter le cas où les entrées sont des listes chainées (première question), et le cas où les
listes sont des tableaux.
// L’idée générale consiste à mettre en place un algorithme récursif capable de trouver les
éléments en commun entre les deux entrées (les deux listes) et appeler toutes les
comparaisons possibles entre les nombres des deux listes. Enfin, arrivé à la condition d’arrêt,
on dépile les appels récursifs stockés dans la pile, mais en comparant la longueur des sous
listes retournées, pour retourner enfin la plus longue sous liste commune entre les deux
listes.

// Fonction récurrente

L1[n-1]^PLSSC(L1 0..n-2, L2 0..m-2)

/ Si L1[n-1] = L2[m-1]
PLSSC (E L1 0..n-1, L2 0..m-2) = {
Max (PLSSC (L1 0..n-1 , L2 0..m-2),PLSSC (L1 0..n-2, L2 0..m-1))
/ Sinon

ß
// Cas PLSSC entre deux listes chainées
// On écrit une fonction qui compare la longueur entre deux listes chaînées.
// Pour i et j : ¯\_(ツ)_/¯

Liste maxListe (E L1, L2 : Liste de caractères) : retourne Liste de caractères

Aux :
CptL1, cptL2 :entiers
cptL1 := 1 ;
cptL2 := 1 ;
Début
Si (L1 = Nil && L2 = Nil) Alors retourner Nil ;
Sinon
Tant que L1 != Nil Alors
CptL1 := cptL1+1 ;
L1 := L1.^suivant ;
Fin Tant que

Tant que L2 != Nil Alors

CptL2 := cptL2+1 ;
L2 := L2.^suivant ;
Fin Tant que

Si (cptL1>cptL2) Alors retourner L1 ;

Sinon retourner L2 ;
Fin Si
Fin SI
Fin maxListe

// Complexité d’ordre O(2max(n,m))

Fonction PLSSC ( E L1, L2 : Listes de caractères) : retourne Liste de caractères

Début
Si (L1 = Nil || L2 = Nil) Alors retourner Nil ;
Sinon Si ( L1.^val != L2.^val ) Alors
Retourner ( maxListe(PLSSC(L1.^suiv, L2) , PLSSC(L1,L2.^suiv)) ) ;
Sinon
L : Liste
L.^val = L1.^val ;
L.^suiv = PLSCC(L1.^suiv,L2.^suiv) ;
Fin Si
Fin PLSSC
// Cas Des deux listes sont des tableaux
// On peut pas retourner un tableau =) d’où la liste chainée, si besoin on peut transformer
facilement une liste chaînée en tableau après l’appel de la fonction

Fonction PLSCC ( E L1,L2 :Tableau d’entiers, E i,j : entiers) retourne Liste d’entiers

{préconditions : i et j sont initialisés à 0}

Début
Si (i = n || j = m) Alors retourner Nil ;
Sinon Si (L1[i] != L2[j]) Alors
Retourner max( PLSCC (L1[i+1], L2[j]), PLSCC (L1[i], L2[j+1])) ;
Sinon
L: Liste;
L ^. Val = L1[i];
L^.suiv = PLSCC (L1[i+1], L2[j+1]);
retourner L;
Fin Si

Fin PLSCC

Exercice 2: Nœuds Cousins

//Pour que deux nœuds soient cousins, il suffit de vérifier si la hauteur de a est égale à la
hauteur de b, et si le parent de a n’est pas le parent de b

// On commence par la vérification des hauteurs

Fonction Hauteur (E A,n : arbre) : retourne entier // n désigne le nœud soit a ou b
Début
SI (A != Nil) Alors
Si (A^.val != n^.val) Alors
Retourner (1 + Hauteur(A^.fg) + Hauteur(A^.fd)) ;
Sinon
Retourner 1 ;
Fin Si
Fin Si
Sinon retourner 0 ;
Fin Hauteur
// Verification du père

Fonction parent (E A ,n :arbre) :retourne Arbre

Début
Si(A != Nil) Alors
Si(A^.fg = n || A^.fd = n)
Retourner A ;
Sinon
parent(A^.fg,n) ;
parent(A^.fd, n) ;
Fin Si
Sinon retourner Nil ;
Fin Si
Fin parent

// Ainsi la fonction finale :

// Complexité d’ordre O(n)

Fonction Cousins (E A, a, b : Arbre) : retourne booléen

Aux :
Ha,Hb : entiers
Pa,Pb : entiers
Début
Ha = Hauteur(A,a) ;
Hb = Hauteur(A,b) ;
Pa = Parent(A,a) ;
Pb = Parent(A,b) ;

Si (Pa != Pb && Ha = Hb) Alors retourner Vrai ;

Sinon retourner Faux ;
Fin Si
Fin Cousins

Exercice 3 :

---> https://www.youtube.com/watch?v=aZjYr87r1b8&t=25s
Exercice 4 :
1)
// La solution consiste à faire un parcours en profondeur de l’arbre, à chaque nœud traversé,
on mets à jour la distance en soustrayant la distance parcourue pour arriver au nœud de la
distance n puis on incrémente le compteur (si on n’a pas dépassé la distance n) et en
ajoutant au compteur le retour de l’appel récursif des autres fils du même nœud 

// Complexité d’ordre O(n)

Fonction Compter (E A: Arbre, n :entier) : retourne entier

Aux :
Cpt : entier ;
Début
Si (A != Nil) Alors
Cpt := 0 ;
Pour i de 0 .. A.Nb_voisins Faire :
Si (n - A^.fils[i].distance >= 0)
Cpt := cpt + 1 + Compter (A^.fils[i], n – A^.distance)) ;
Sinon
Retourner 0 ;
Fin Pour
Retourner cpt ;
Sinon retourner 0 ;
Fin Si
Fin Compter
2)

// l’idée est de comparer la distance parcourue dans chaque branche (fils du noeud) pour
arriver soit à s ou bien à la fin de l’arbre, on compare les fils l’un à l’autre en retournant la
distance parcourue pour arriver à la ville (s) où bien à la valeur sentinelle (1000)

// Complexité d’ordre O(n)

Fonction Trouver(E A : Arbre, s : texte) : retourne entier

Aux :
Tmp :entier ;
Tmp := 1000 ;
Début
Si (A != Nil) Alors
Si (A^.nom = s) Alors retourner A^.distance ;
Sinon
Si(A.^Nb_voisins = 0) Alors retourner 1000 ;
Sinon Si (A.^Nb.voisins = 1) Alors
Retourner A.^Distance + Trouver(A^.fils[0], s) ;
Sinon
Pour i de 0 .. (A.Nb_voisins – 1) Faire :
tmp= min( tmp, min (Trouver(A^.fils[i],s),Trouver(A^.fils[i+1],s)));
Fin Pour
Retourner A^.distance + tmp ;
Sinon retourner 1000 ;
Fin Si 
Fin Trouver