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] }