UHBC - Dept d'informatique 2010/2011

Master Ingénierie des Logiciels

Algorithmique Avancée et Complexité
Corrigé d'examen

Exercice 1 :
1. Écrivez un algorithme de type diviser-pour-régner qui résout ce problème.
Correction. On coupera le tableau en deux moitiés, comptera les e dans chaque moitie, et additionnera les
résultats:
Fonction Compter(Entré A: Tableau[1..n] réel;s,f: entier,e:Réel): Entier
Début
si s=f
Alors si (A[s]=e) Alors Compter:= 1
sinon Compter:= 0;
Fsi;
Sinon
m=(s+f)/2
gauche=Compter(A,s,m,e)
droite=Compter(A,m+1,f,e)
Compter:=gauche +droite;
Fsi;
Fin;

2. Analyser sa complexité.
Correction. Le problème pour un tableau de taille n est réduit aux deux sous-problèmes de taille n=2 ,
et encore O(1) opérations, d’où la récurrence sur la complexité :
T(n) = 2T(n/2) + O(1):
Par Master theorem (avec k = log2 2), on déduit que T(n) = O(n).
3. Comparer-la avec celle de l’algorithme naïf.
Correction. L’algo naïf comporte une boucle de n itérations, le corps de boucle se fait en O(1). Sa
complexité est donc O(n). Conclusion : l’algo Diviser-pour-régner a la même complexité que l’algo naïf.

Fonction CompterNaif(Entré A: Tableau[1..n] réel;s,f: entier,e:Réel): Entier ;

Début
Var Acc: entier;
Acc:=0;
pour i de s à f Faire si (A[i]=e) Alors acc:=acc+1; Fsi;
Fait;
CompterNaif:= acc;
Fin;
Exercice 2:
Considérez l’arbre de jeu suivant. La racine est un noeud max.

1. Appliquez l’algorithme minimax sur cet arbre.

2. Appliquez l’algorithme α-β sur cet arbre en le parcourant de gauche à droite.
Correction:

Application de l'algorithme Minimax Application de l'élagage Alpha-Bêta

Exercice 3:
Soit le graphe suivant, la valeur portée sur chaque arc correspond au coût de passage d'une extrémité de l'arc à
l'autre. On souhaite calculer le plus court chemin de A à J.

On a de plus la fonction heuristique h qui estime le coût pour atteindre J depuis chaque sommet. h est donnée par
le tableau ci dessous.

Question : Appliquez l'algorithme A* avec la fonction h sur ce graphe (précisez à chaque étape de l'algorithme le
contenu de la liste Ouvert et la liste Fermé).
Correction:
On représente le déroulement de l'algorithme sous forme de tableau. Chaque ligne du tableau correspond à un tour
de boucle de l'algorithme. La première colonne indique le numéro de tour de l'algo, dans la deuxième colonne on
indique le sommet choisi. Dans la troisième colonne l'ensemble des ouverts de l'étape courante est représenté,
chaque état est noté sous le format « sommet (père, g(x), f(x)=g(x)+h(x)) ». La dernière colonne contient
l'ensemble des fermés de l'étape courante.
Etape Choix Ouverts Fermés
Init {A(Nil,0,16)} {}
1 A(Nil,0,16 {B(A,2,16); C(A,5,15); E(A,3,16)} {A(Nil,0,16)}
2 C(A,5,15) {B(A,2,16); E(A,3,16); D(C,9,20); {A(Nil,0,16), C(A,5,15)}
F(C,9,16); G(C,14,18)}}
3 B(A,2,16) { E(A,3,16); D(B,7,18); F(C,9,16); {A(Nil,0,16); C(A,5,15); B(A,2,16)}
G(C,14,18)}
4 E(A,3,16) { D(B,7,18); F(C,9,16); G(C,14,18); {A(Nil,0,16); B(A,2,16); E(A,3,16)}
C(E,4,14); I(E,14,20)}
 5 C(E,4,14) { D(B,7,18); F(C,8,15); G(C,13,17); {A(Nil,0,16); B(A,2,16); E(A,3,16); C(E,4,14)}
I(E,14,20)}
6 F(C,8,15) { D(B,7,18); G(C,13,17); I(E,14,20); {A(Nil,0,16); B(A,2,16); E(A,3,16); C(E,4,14);
H(F,10,17); } F(C,8,15)}
7 H(F,10,17) { D(B,7,18); G(H,12,16); I(E,14,20); {A(Nil,0,16); B(A,2,16); E(A,3,16); C(E,4,14);
J(H,19,19); } F(C,8,15); H(F,10,17) }
8 G(H,12,16); { D(B,7,18); I(E,14,20); J(G,18,18); } {A(Nil,0,16); B(A,2,16); E(A,3,16); C(E,4,14);
F(C,8,15); H(F,10,17); G(H,12,16); }
9 J(G,18,18); {A(Nil,0,16); B(A,2,16); E(A,3,16); C(E,4,14);
F(C,8,15); H(F,10,17); G(H,12,16); J(G,18,18)}
Remarques :
– A l'initialisation, on met dans Ouverts, le sommet de départ;
– A chaque étape on choisit dans Ouverts un sommet s tel que f(s)=g(s)+h(s) soit minimal. Pour tous les voisins v
de s, si v n'appartient ni à Ouverts ni à fermés, on ajoute v à Ouverts. Sinon on remet v dans Ouverts avec une
nouvelle valeur de g(v) seulement si g(s)+coût(s->v) est inférieur à la valeur de g(v)mémorisée.
– A l'étape 3, après sélection du sommet B, la valeur de g(D) dans Ouverts passe de 9 à 7;
– A l'étape 4, après sélection du sommet E, la valeur de g(C) passe de 5 à 4 et C passe des Fermés aux Ouverts;
– A l'étape 5, les valeurs de g de F et G dans Ouverts passent respectivement de 9 à 8 et de 14 à 13;
– A l'étape 7, la valeur de g de G dans Ouverts passe de 13 à 12;
– A l'étape 8, la valeur de g de J dans Ouverts passe de 19 à 18.
Le chemin le plus court de A à J est donc A-E-C-F-H-G-J, et est de longueur 18.

Exercice 4:
1. Le résultat est-il optimal en choisissant l’objet le plus cher parmi ceux qui peuvent tenir dans le sac, puis le plus
cher parmi ceux qui peuvent encore tenir . . . Expliquez par un exemple.
Correction: Le résultat n'est pas optimal, considérons l'exemple où on a : W=10, v(8,6,5,3,1) w=(10,4,6,5,3); dans
ce cas on optera pour l'objet n° 1 ayant une valeur=8 alors que la sol optimale est de prendre le 2eme et le 3eme
pour une valeur=11
2. Écrivez un algorithme glouton qui résout ce problème.
Correction.
D'abord il faut trier le vecteur v et w par ordre de v décroissant
Puis, on prendra les objets dans l’ordre tant qu’ils rentrent dans le sac :
Procédure Butin (Entrée v,w: tableau [1..n] réel; W: Entier; Sortie I: Entier, T: Réel);
Début
Var P : Réel;
Trier (v,w);
I:=0 ; P:=0 ; T:=0
Tant que i<n et P+w[i+1]<W
Faire P=P+w[i+1];
T=T+v[i+1];
i:=i+1;
Fait;
/* Les objets dans le sac à dos sont de 1..i leur valeur est T */
Fin;

Procédure Trier (Entrée/Sortie v,w: tableau [1..n] réel);

Début
Var i,j,m : Entier;
Pour i:=1 à n-1
Faire m:=i;
Pour j:=1 à n
Faire Si v[m]>v[j] Alors m:=j; Fait
Si i<>m Alors Permuter (v[i],v[m]); Permuter (w[i],w[m]); Fsi;
Fait;
Fin;