Cours conception et analyse d`algorithmes Correction du TD 6

Cours conception et analyse d’algorithmes
Correction du TD 6
1. Probl`eme du placement d’usines
i. Le coˆut d’une affectation donn´ee par une bijection πde {1,...,n}vers {1,...,n}(l’usine Ui
est affect´e `a l’emplacement Eπ(i)) est C(π) = X
1≤i<j≤n
vi,jcπ(i),π(j).
Une affectation partielle est d´efinie par deux sous-ensembles Iet Pde {1,...,n}correspondant
respectivement aux usines et aux emplacements affect´es et par une bijection αde Ivers P(l’usine
Uiest affect´ee `a l’emplacement Eα(i)). On notera ´egalement J={1,...,n}\Iet Q={1,...,n}\P.
Une borne inf´erieure sur le coˆut d’une affectation πcompl´etant une application partielle (I, P, α)
est donn´ee par
B(I, P, α) = X
i<i0∈I
vi,i0cα(i),α(i0)+X
i∈I,j∈J
vi,j cα(i),βi(j)+X
j<j0∈J
vj,j0cγ(j,j0),
o`u ∀i∈I,βiest une bijection de Jvers Qtelle que ∀j, j0∈J,vi,j < vi,j0⇒cα(i),βi(j)≥cα(i),βi(j0)
et o`u γest une bijection de J2vers Q2telle que ∀j, j0, k, k0∈J,vj,j0< vk,k0⇒cγ(j,j0)≥cγ(k,k0).
ii. Le calcul des bijections βi∀i∈Iet de la bijection γrevient `a faire ptris sur q´el´ements
(coˆut O(pq log q)) plus un tri sur q2´el´ements (coˆut O(q2log(q))). Il faut ensuite sommer toutes les
contributions (coˆut O(n2)). On obtient donc une complexit´e O(n2+pqlog(q) + q2log(n)) qui est
major´ee par O(n2logn).
iii. Pour l’affectation πle coˆut est C(π) = 22. La borne inf´erieure pour l’affectation partielle
α:A7→ dest B({A},{d}, α) = 22 qui n’est pas inf´erieure `a C(π). Cette branche ne sera donc pas
explor´ee lors d’un algorithme branch and bound.
iv. L’arbre repr´esentant une recherche branch and bound avec connaissance `a priori d’une af-
fectation πde score C(π) = 22 est d´essin´e ci-dessous.
B7→ dB 7→ b B 7→ c
∅
B7→ dB 7→ bB 7→ a
22 22 22 22 22 22
2221 2122
A7→ a A 7→ b A 7→ c A 7→ d
1

2. Recouvrement d’ensembles et de mots
I. Recouvrement par ensembles est N P-complet.
La version de d´ecision du probl`eme Recouvrement par ensembles prend comme donn´ees
un ensemble fini E, une famille Sde sous-ensembles de E, une function poids w:S 7→ Net un
entier Wet r´eponds `a la question existe-t-il un ensemble J⊆ {1, . . . , n}tel que ∪j∈JSj=Eet
Pj∈Jw(Sj)≤W?
Recouvrement d’ensemble est un probl`eme dans N Ppuisque ´etant donn´ee une solution J
il est facile de calculer en temps polynomial l’union ∪j∈JSjen temps polynomial (pour le comparer
`a E) et la somme Pj∈Jw(Sj) (pour le comparer `a W).
On r´eduit Recouvrement par sommets `a Recouvrement d’ensemble comme suit. Sup-
posons donn´e un graphe G= (V, E) et un entier k. On consid`ere la famille S={Sv}v∈V, o`u Svest
l’ensemble des arˆetes incidente au sommet v. On choisi un poids w(Sv) = 1 pour tout sommet v.
Avec ces notations, un ensemble X⊆Vest un ensemble de sommets recouvrant du graphe Gsi
et seulement si ∪v∈XSx=E. De plus, le cardinal de Xest ´egal `a son poids w(X) = Pv∈Xw(Sv).
Donc recouvrement par sommet(G= (V, E), k) donne la mˆeme r´eponse que recouvrement
par ensemble(E, S, w, k).
Puisque Recouvrement par sommets est N P-complet et que la r´eduction propos´ee est
polynomiale, Recouvrement d’ensemble est aussi N P-complet.
II Algorithme approch´e glouton.
1. Soit J={j1,...,jp}un recouvrement optimal. On a
W0=X
j∈J
w(Sj) = X
j∈J
w(Sj)
|Sj|× |Sj| ≥ min
j∈J(w(Sj)
|Sj|)×X
j∈J
|Sj| ≥ min
j∈J(w(Sj)
|Sj|)×n.
Donc W0
n≥min
j∈J(w(Sj)
|Sj|).
A l’´etape 1, l’algorithme glouton choisit T1tel que c(T1) = w(T1)
|T1|soit minimum. Comme ce
minimum est inf´erieur ou ´egal `a W0
n, on obtient bien w(T1)
|T1|≤W0 n.
2. A l’´etape ion peut restreindre le probl`eme `a F=E\F, consid´erer les sous-ensembles S0
i=Si\F
et supposer que l’on est au d´ebut de l’algorithme. L’optimal pour ce probl`eme est W0
0≤W0et par
la question pr´ec´edente on obtient c(Ti)≤W0
0
|F|et par suite c(Ti)≤W0
n−j+ 1 .
3. Le poids de la solution obtenue par l’algorithme glouton est W=Pk
i=1 w(Ti). Si l’ensemble
Ticontient les ´el´ements xjpour j=αi, αi+ 1,...,βi, alors la question pr´ec´edente montre que
c(Ti) = w(Ti)
βi−αi≤W0 n−αi+1 . Donc w(Ti)≤W0βi−αi n−αi+1 ≤W0Pβi
j=αi
1
n−j+1 . Par cons´equent W W0≤
Pk
i=1 Pβi j=αi
1
n−j+1 =Hn. L’algorithme est donc Hnapproch´e.
4. On peut prendre comme poids w(Si) = 1/i pour i= 1,...,n et w(Sn+1) = (1 + ε). L’algorithme
choisit alors Snpuis Sn−1et ainsi de suite jusqu’`a S1obtenant un poids Hn. La solution optimale
est obtenu en prenant Sn+1 qui a poids ((1 + ε)/n). Noter que l’´enonc´e imposait des poids entiers,
il convient donc de multiplier tous les poids par n! pour satisfaire cette condition.
III. Recouvrement de mots.
2

1. Le mot σ12kest abkcet le foptimal est abk+1c.
2. L’algorithme `a ´egalit´e de longueur de chevauchements pour l’exemple pr´ec´edent peut choisir σ12k
qui donne un ensemble S={abkc, bk+1}compos´e de deux mots qui n’ont qu’un 0-chevauchement
d’o`u la solution obtenue abkc, bk+1. Cette solution est de longueur 2k+ 3 alors que la solution
optimale est de longueur k+ 2. Le facteur d’approximation est sup´erieur ou ´egal `a 2k+3
k+2 qui aussi
proche que l’on veut de 2.
3. Il suffit de prendre pour fla concat´enation des mots θ1, θ2,...θp. Comme les Sθirecouvrent
S, tout fjest ´el´ement d’un des Sθi, donc facteur du θicorrespondant. Le poids W0de la solution
optimale au probl`eme Qest ´egal `a la somme des longueurs des mots θi, qui est exactement la
longueur de f.
4. Soit k∈ {1,...,n}. On va montrer que fkest dans un des sous-ensemble Sπi. Puisque 1 = b1<
e1< b2< e2<···< bt< et=net que bi=ei−1+ 1, il existe un indice itel que bi< k < ei. Donc,
le facteur fkcommence apr`es fbiet avant fei. Comme on suppose que les fine sont pas facteurs les
uns des autres, le facteur fktermine avant fbi. Donc fkest contenu dans le sous mot πi=σbieiki
et il appartient `a l’ensemble Sπi. Les Sπiconstituent donc un recouvrement de S.
5. Soit i∈ {1,...,t−2}. Par d´efinition, le facteur fbi+1 commence apr`es feidans le mot f(car
bi+1 > ei) donc fbi+1 termine apr`es fei(car fbi+1 n’est pas facteur de fei). D’autre part, fbi+1
termine avant que fbi+2 ne commence. Donc feitermine avant que fbi+2 ne commence. Donc πiet
πi+2 ne s’intersectent pas.
On en d´eduit que X
ipair
l(πi)≤l(f) et X
iimpair
l(πi)≤l(f). Donc X
i
l(π)≤2l(f).
6. On consid`ere l’algorithme qui remplace le probl`eme Psur les mots par le probl`eme Qcorres-
pondant sur les ensembles, puis qui r´esout Qpar l’algorithme glouton de la partie II, enfin qui
concat`ene les mots ucorrespondants aux Sude la solution trouv´ee.
D’apr`es les questions II.3,II.4,II.5, on sait que s’il existe une solution de poids lpour le probl`eme
Pde recouvrement de mots, alors il existe aussi une solution de poids au plus 2lobtenu en passant le
probl`eme Qcorrespondant. On obtient une solution de poids au plus 2lHnen utilisant un algorithme
glouton pour r´esoudre le probl`eme P. Notre algorithme est donc 2Hnapproch´e.
3