transparents en partie traduits de ceux du livre de...
TRANSCRIPT
Programmation dynamique
Transparents en partie traduits de ceux du livre de Kleinberg et Tardos “Algorithm Design”
2
Programmation dynamique
Technique algorithmique : générale et puissante
Programmation dynamique : (presque) de la recherche exhaustive
où on essaie toutes les possibilités d’une manière intelligente
Programmation dynamique : sous-problèmes et reutilisation
3
Nombre de Fibonacci
Pourquoi le nom de programmation dynamique ?
Il a donné un nom impressionnant pour être accepté par le Secrétaire de Défense Américain qui n’aimait pas la recherche mathématique
4
Nombres de Fibonacci
0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, …
!"
!#
$
=
=
≥+
=−−
0 if 0 1 if 1 2 if 21
NNNFF
FNN
N
fib(N) si N<2 : f=N sinon f=fib(N-1)+ fib(N-2) retourner f
Objectif: calculer le Nème nombre de Fibonacci
Exponentiel !!!
F(40)
F(39) F(38)
F(38)
F(37) F(36)
F(37)
F(36) F(35)
F(36)
F(35) F(34)
F(37)
F(36) F(35)
5
Mémoisation
Algorithme de programmation dynamique avec mémoisation memo={} %un dictionnaire fib(N): si N dans memo : retourner memo[N] si N < 2 : f = N sinon : f = fib(N-1)+fib(N-2) memo[N]=f retourner f
Méthode générale pour rendre un algorithme récursif efficace
Pourquoi ? fib(k) fait des appels recursifs uniquement la première fois qu’elle est appelée, pour chaque k
un appels mémoisé : temps constant nombre d’appels non-mémoisés : N (fib(1),…,fib(N)) travail non-récursif à chaque appel : temps constant => temps en O(N)
6
Programmation dynamique : (presque) recursion + mémoisation
mémoiser (se rappeler) et réutiliser des solutions à des sous-problèmes qui aident à la résolution du problème initial
temps= (nombre de sous-problèmes) x (temps par sous-problème)
Pour le nombre de Fibonacci :
nombre de sous-problèmes = N temps par sous-problème = constant (on ne compte pas les recursions)
7
Du bas vers le haut (Bottom-up)
Itératif(N) f[0]=0, f[1]:=1 pour i=2 jusqu’à N: f[i]=f[i-1]+f[i-2] retourner f[N]
En général,
- même calcul que dans le cas de programmation dynamique mémoisée
- tri topologique du graphe orienté sans circuit des sous-problèmes
FnFn-1Fn-2Fn-3
On peut gagner en mémoire
8
Plus court chemin δ(s,v) pour tout vOn ne connait pas la réponse ? Alors il faut la deviner !
s vu
un plus court chemin hypothétique
Deviner le dernier sommet
δ(s,v)=min (δ(s,u)+w(u,v))(u,v)
appel récursif
δ(s,s)=0Exponentiel sans mémoisation
Essayer toutes les possibilités (et choisir la meilleure)
9
Plus court chemin δ(s,v) pour tout v
Est-il un bon algorithme ? (imaginons qu’on a utilisé la mémoisation)
b
a
vs
δ(s,v)
δ(s,a)
δ(s,b)
δ(s,s) δ(s,v)
=> temps infini pour graphes avec cycles
10
Plus court chemin δ(s,v) pour tout v
Pour DAGs : O(|V|+|E|)
Temps= (# de sous-problèmes) x (temps par sous-problème) # de sous-problèmes = |V| temps pour sous-problème δ(s,v) = (nombre d’arcs entrants à v)+1
Temps total = Σ degré entrant de v + 1= O(|V|+|E|)v
A retenir
les dépendances des sous-problèmes doivent être acycliques
11
Plus Court chemin dans les graphes avec cycles
Rendre un graphe avec cycles acyclique
temps
δk(s,v) = le poids d’un plus court chemin de s à v utilisant au plus k arcs
δk(s,v)=min (δk-1(s,u)+w(u,v))(u,v)
12
Plus Court chemin dans les graphes avec cycles
# de sous-problèmes : O(|V|2)
puisque on veut calculer δ|V|-1(s,v)
Temps total : O(|V||E|)
(Bellman-Ford)
Ordonnancement d’ Intervalles
14
Ordonnancement d’intervalles
■ La tâche j commence à sj, finit à fj, et a un poids de valeur vj . ■ Deux tâches sont compatibles si elles ne se chevauchent pas. ■ But : déterminer un sous-ensemble de tâches mutuellement
compatibles de poids maximum.
Time0 1 2 3 4 5 6 7 8 9 10 11
f
g
h
e
a
b
c
d
15
Ordonnancement d’intervalles non-pondérés
Fait. Si tous les poids sont 1, on peut utiliser glouton : ■ Considérons les tâches dans l’ordre croissant de leurs dates de fin. ■ Ajouter une tâche dans le sous-ensemble si elle est compatible avec
les tâches déjà choisies.
Observation. Dans le cas pondéré glouton peut se tromper énormément.
Temps0 1 2 3 4 5 6 7 8 9 10 11
b
a
poids = 999
poids = 1
16
Ordonnancement d’intervalles pondérés
Notation. Numéroter selon les dates de fin : f1 ≤ f2 ≤ . . . ≤ fn . Déf. p(j) = l’indice max i < j tel que la tâche i est compatible avec j.
Ex: p(8) = 5, p(7) = 3, p(2) = 0.
Temps0 1 2 3 4 5 6 7 8 9 10 11
6
7
8
4
3
1
2
5
17
Programmation Dynamique : Choix Binaire
Notation. OPT(j) = valeur de la solution optimale pour le problème avec les tâches 1, 2, ..., j.
■ Cas 1 : OPT choisit la tâche j. – tâches incompatibles : { p(j) + 1, p(j) + 2, ..., j - 1 } – doit inclure la solution optimale pour le problème 1, 2, ..., p(j)
■ Cas 2: OPT ne choisit pas la tâche j. – doit inclure la solution optimale pour le problème 1, 2, ..., j-1
€
OPT( j) =0 if j = 0
max v j + OPT( p( j)), OPT( j −1){ } otherwise# $ %
sous-structure optimale
18
Entrée: n, s1,…,sn , f1,…,fn , v1,…,vn
Trier tâches par dates de fin f1 ≤ f2 ≤ ... ≤ fn.
Calculer p(1), p(2), …, p(n)
Calculer-Opt(j) { si (j = 0) retourner 0 sinon retourner max(vj + Calculer-Opt(p(j)), Calculer-Opt(j-1)) }
Ordonnancement d’intervalles pondéré : recherche exhaustive
19
Ordonnancement d’intervalles pondérés : recherche exhaustive
Observation. algorithme exponentiel
Ex. Nombre d’appels récursifs pourrait augmenter comme dans le cas d’une suite de Fibonacci.
34
5
12
p(1) = 0, p(j) = j-2
5
4 3
3 2 2 1
2 1
1 0
1 0 1 0
Mémoisation. Stocker les résultats de chaque sous-problème.
20
Entrée: n, s1,…,sn , f1,…,fn , v1,…,vn
Trier tâches par date de fin f1 ≤ f2 ≤ ... ≤ fn. Calculer p(1), p(2), …, p(n)
pour j = 1 à n M[j] = vide M[j] = 0
M-Calculer-Opt(j) { si (M[j] est vide) M[j] = max(wj + M-Compute-Opt(p(j)), M-Compute-Opt(j-1)) return M[j] }
tableau global
Ordonnancement d’intervalles pondérés : Mémoisation
21
Ordonnancement d’intervalles pondérés : Temps de calcul
Assertion. La version mémoisée prends un temps en O(n log n). ■ Tri par date fin : O(n log n). ■ Calculer p(⋅) : O(n) après un tri par date de début.
■ M-Calculer-Opt(j): chaque appel prend un temps en O(1) time et soit – (i) retourne une valeur existante M[j] – (ii) soit il remplit une nouvelle entrée M[j] et fait deux appels
récursifs
■ Mesure de progression Φ = # d’entrée non-vides M[]. – initialement Φ = 0, et Φ ≤ n. – (ii) augmente Φ de 1 ⇒ au plus 2n appels récursifs.
■ Temps total de M-Compute-Opt(n) est en O(n). ▪
Remarque. O(n) si les tâches sont triées par date de début et de fin.
Q. Comment déterminer la solution ? A. Effectuer un post-traitement
■ # d’appels récursifs ≤ n ⇒ O(n).
Faire Tourner M-Calculer-Opt(n) Faire Tourner Déterminer-Solution(n)
Déterminer-Solution(j) { si (j = 0) retourner rien sinon si (vj + M[p(j)] > M[j-1]) print j Déteminer-Solution(p(j)) sinon Déterminer-Solution(j-1) }
22
Ordonnancement d’intervalles pondérés : Déterminer une solution
23
Ordonnancement d’intervalles pondérés : Bottom-Up
Entrée: n, s1,…,sn , f1,…,fn , v1,…,vn
Trier les tâches par date de fin f1 ≤ f2 ≤ ... ≤ fn.
Calculer p(1), p(2), …, p(n)
Itérativement-Calculer-Opt { M[0] = 0 pour j = 1 à n M[j] = max(vj + M[p(j)], M[j-1]) }
Le Problème du sac-à-dos
25
Le Problème du sac-à-dos
■ n objets et un “sac-à-dos.” ■ Le poids de l’objet i est wi > 0 et sa valeur est vi > 0. ■ Le sac-à-dos a une capacité de W. ■ Objectif: remplir le sac-à-dos afin de maximiser la valeur totale
Ex: { 3, 4 } a une valeur de 40.
Glouton : ajouter à chaque fois l’objet maximisant vi / wi. Ex: { 5, 2, 1 } conduit à 35 ⇒ glouton n’est pas optimal.
1
valeur
182228
1
poids
56
6 2
7
objet
1
345
2W = 11
26
Programmation Dynamique : un faux départ
Déf. OPT(i) = sous-ensemble de profit maximum de 1, …, i.
■ Cas 1 : OPT ne choisit pas l’objet i. – OPT choisit la solution optimale de { 1, 2, …, i-1 }
■ Cas 2 : OPT choisit l’objet i. – le choix de i n’implique pas immédiatement que nous devrons rejeter
d’autres objets – sans connaitre quels autres objets ont été choisis avant i, nous ne
connaissons pas combien de capacité reste pour i
Conclusion. nous avons besoin de plus de sous-problèmes !
27
Programmation Dynamique : ajout d’une nouvelle variable
Déf. OPT(i, w) = sous-ensemble de profit max profit de 1, …, i avec un poids limite de w.
■ Cas 1 : OPT ne choisit pas i. – OPT choisit une solution optimale pour { 1, 2, …, i-1 } avec un poids
limite de w
■ Cas 2 : OPT choisit l’objet i. – nouveau poids limite = w – wi – OPT choisit une solution optimale pour { 1, 2, …, i–1 } avec le nouveau
poids limite
€
OPT(i, w) =
0 if i = 0OPT(i −1, w) if wi > wmax OPT(i −1, w), vi + OPT(i −1, w−wi ){ } otherwise
#
$ %
& %
Remplir un tableau n-par-W.
28
Entrée : n, w1,…,wN, v1,…,vN
pour w = 0 à W M[0, w] = 0
pour i = 1 à n pour w = 1 à W si (wi > w) M[i, w] = M[i-1, w] sinon M[i, w] = max {M[i-1, w], vi + M[i-1, w-wi ]}
retourner M[n, W]
Le Problème du sac-à-dos : Bottom-Up
29
Le Problème du sac-à-dos
n + 1
1valeur
182228
1poids
56
6 2
7
objet1
345
2
φ
{ 1, 2 }
{ 1, 2, 3 }
{ 1, 2, 3, 4 }
{ 1 }
{ 1, 2, 3, 4, 5 }
0
0
0
0
0
0
0
1
0
1
1
1
1
1
2
0
6
6
6
1
6
3
0
7
7
7
1
7
4
0
7
7
7
1
7
5
0
7
18
18
1
18
6
0
7
19
22
1
22
7
0
7
24
24
1
28
8
0
7
25
28
1
29
9
0
7
25
29
1
34
10
0
7
25
29
1
34
11
0
7
25
40
1
40
W + 1
W = 11
OPT: { 4, 3 } valeur = 22 + 18 = 40
30
Le Problème du sac-à-dos : temps d’exécution
Θ(n W). ■ Pas polynomial par rapport à la taille de l’entrée ! ■ "Pseudo-polynomial." ■ Version de décision du problem : problème NP-complet.
Alignment de séquences
32
Similarité de chaînes
■ ocurrance ■ occurrence
o c u r r a n c e
c c u r r e n c eo
-
o c u r r n c e
c c u r r n c eo
- - a
e -
o c u r r a n c e
c c u r r e n c eo
-
5 différences, 1 gap
1 différence, 1 gap
0 différences, 3 gaps
33
Applications. ■ Unix diff. ■ Reconnaissance vocale. ■ Computational Biologie Computationnelle.
Distance d’Edition. [Levenshtein 1966, Needleman-Wunsch 1970] ■ Pénalité de gap δ; penalité de différence αpq. ■ Coût = somme de pénalités pour les gaps et les différences.
2δ + αCA
C G A C C T A C C T
C T G A C T A C A T
T G A C C T A C C T
C T G A C T A C A T
-T
C
C
C
αTC + αGT + αAG+ 2αCA
-
Distance d’Edition
34
But: Etant données deux chaînes X = x1 x2 . . . xm et Y = y1 y2 . . . yn déterminer un alignment de coût minimum.
Déf. Un alignment M est un ensemble des paires ordonnées xi-yj chaque lettre apparait à au plus une paire sans croisements.
Def. The pair xi-yj and xi'-yj' cross if i < i', but j > j'.
Ex: CTACCG vs. TACATG. Sol: M = x2-y1, x3-y2, x4-y3, x5-y4, x6-y6.
Alignment de séquences
€
cost( M ) = αxi y j(xi, y j )∈ M∑
mismatch! " # $ #
+ δi : xi unmatched
∑ + δj : y j unmatched
∑
gap! " # # # # # $ # # # # #
C T A C C -
T A C A T-
G
Gy1 y2 y3 y4 y5 y6
x2 x3 x4 x5x1 x6
35
Alignment de séquences : Structure du Problème
Déf. OPT(i, j) = coût min pour l’alignement x1 x2 . . . xi and y1 y2 . . . yj. ■ Cas 1: OPT couple xi-yj.
– payer pour la différence xi-yj + coût min pour aligner les chaînesx1 x2 . . . xi-1 and y1 y2 . . . yj-1
■ Cas 2a: OPT laisse xi non-couplé. – payer le gap pour xi et le coût min pour aligner les chaînes x1 x2 . . . xi-1
et y1 y2 . . . yj ■ Cas 2b: OPT laisse yj non-couplé.
– payer le gap pour yj et le coût min pour aligner les chaînes x1 x2 . . . xi et y1 y2 . . . yj-1
€
OPT(i, j) =
"
#
$ $ $
%
$ $ $
jδ if i = 0
min
αxi y j+ OPT(i −1, j −1)
δ + OPT(i −1, j)δ + OPT(i, j −1)
"
# $
% $
otherwise
iδ if j = 0
36
Alignment de séquences : Algorithme
Analyse. Θ(mn) temps et espace. Mots français ou phrases : m, n ≤ 10. Biologie Computationelle: m = n = 100,000. 10 billions ops OK, mais tableau 10GB ?
Sequence-Alignment(m, n, x1x2...xm, y1y2...yn, δ, α) { pour i = 0 à m M[0, i] = iδ pour j = 0 à n M[j, 0] = jδ
pour i = 1 à m pour j = 1 à n M[i, j] = min(α[xi, yj] + M[i-1, j-1], δ + M[i-1, j], δ + M[i, j-1]) retourner M[m, n] }