Chapitre v algorithmes gloutons

CHAPITRE V:

ALGORITHMES GLOUTONS

Université Saad Dahleb de Blida

Faculté des Sciences

Département d’Informatique

Licence Génie des Systèmes Informatique (GSI)

Semestre 5 (3ème année)

ALGORITHMIQUE 02

Cours n°12: 24 Novembre 2013

AROUSSI Sana

Disponible sur https://sites.google.com/a/esi.dz/s-aroussi/

https://sites.google.com/a/esi.dz/s-aroussi/



PLAN DU CHAPITRE V

Introduction

Schéma Général

Preuve d’Optimalité

Exemples

2

3

On est souvent dans le cadre des problèmes

d'optimisation:

E: un ensemble fini d'éléments.

S: une solution est construite à partir des éléments de E. Par

exemple: une partie de E, un multi-ensemble d'éléments de E, une

suite fini de E ou une permutation de E qui satisfait une certaine

contrainte.

A chaque solution S est associée une fonction objectif F(S).

Le but est de chercher une solution qui optimise (minimise ou

maximise) cette fonction objectif.

INTRODUCTION PROBLÈME D’OPTIMISATION

4

Pour un problème d’optimisation, un algorithme glouton

est un algorithme qui cherche à construire une

solution pas à pas

sans jamais revenir sur ses décisions,

en prenant à chaque étape la solution qui

semble la meilleure localement,

en espérant obtenir une solution optimale.

INTRODUCTION PRINCIPE GÉNÉRAL

5

Algorithme Glouton Exact

Choix glouton optimal

Algorithme Glouton Exact

Choix glouton: Solution non optimale Choix glouton: Solution non optimale

Heuristique Gloutonne

INTRODUCTION PRINCIPE GÉNÉRAL

6

On dispose des pièces de monnaie correspondant aux

valeurs E = {e1, ..., en}.

Pour chaque valeur ei, le nombre de pièces (nbi) est non

borné.

Étant donnée une somme « s » entière, on veut trouver

une façon de rendre la somme « s » avec un nombre de

pièces minimum.

Prendre E ={1, 10, 2, 5}, s = 28, Quelles la solution

optimale?

EXEMPLE 1: LE MONNAYEUR

7

Une solution S = (nb1, ...., nbn) présente le nombre de

pièces (nbi) pour chaque valeur (ei):

Elle est correcte si

Elle est optimale si est minimal.

Algorithme glouton: Trier les valeurs de pièces par

ordre décroissant. Pour chaque valeur de pièce,

maximiser le nombre de pièces choisies.


8

Trier E en ordre décroissant

Pour i 1 à n faire

DP

S[i] s div E[i]

s s mod E[i]

FP


1ÈRE VERSION

9

Il est basé sur un critère local de sélection des

éléments de E pour construire une solution optimale. En

fait, on travaille sur l'objet « solution partielle » et on

doit disposer des modules suivant:

Init qui initialise la solution de début

Select qui choisit le meilleur élément restant selon le

critère glouton: Souvent, on trie tout simplement la liste des

éléments selon le critère glouton au départ et on balaye

ensuite cette liste dans l'ordre.

SCHÉMA GÉNÉRAL

10

Init qui initialise la solution de début

Select qui choisit le meilleur élément restant selon le critère

glouton: Souvent, on trie tout simplement la liste des éléments

selon le critère glouton au départ et on balaye ensuite cette liste

dans l'ordre.

Complete? qui teste si une solution partielle est une solution

(complète).

AjoutPossible? qui teste si un élément peut être ajouté à une

solution partielle. Dans certains cas, c'est toujours vrai!

Ajout qui permet d'ajouter un élément à une solution si c'est

possible.

SCHÉMA GÉNÉRAL

11

L’algorithme Glouton est alors:

Trier (E)

Init (S)

Tant que Non Complete(S) faire

Select(x, E)

Si AjoutPossible(x) alors Ajout(S, x)

FTQ

SCHÉMA GÉNÉRAL

12

Trier (E) //en ordre décroissant

Init (S) //Initialiser la solution à 0 (nbi = 0)

i1

Tant que (i n) faire // La solution est complète après

avoir parcouru tous les éléments de E

// Select retourne E(i)

// AjoutPossible est toujours vrai

S[i] s div E[i] // Ajouter la solution

s s mod E[i]

i ++

FTQ


SCHÉMA GLOUTON

13

Soit n la cardinalité de E

Trier (E)

Init (S)

Tant que Non Complete(S) faire

Select(x, E)

Si AjoutPossible(x) alors Ajout(S, x)

FTQ

SCHÉMA GÉNÉRAL

COMPLEXITÉ

La complexité est souvent de l’ordre O ( n log2 n + n f(n) ) La complexité est souvent de l’ordre O ( n log2 n + n f(n) )

O (T ) = O(n log n) O (Ttrier ) = O(n log2 n)

TInit TInit Tcomplete Tcomplete

Tselect Tselect

Tpossible Tpossible TAjout TAjout

n fois n fois

f(n) f(n)

14


COMPLEXITÉ DU SCHÉMA GLOUTON

O (Ttrier) = O ( n log2 n ) O (Ttrier) = O ( n log2 n )

Trier (E)

Init (S)

i1

Tant que (i n) faire

S[i] s div E[i]

s s mod E[i]

i ++

FTQ

15

Dans certains cas, le schéma général est encore plus

simple! Comme dans le cas de MONNAYEUR.

Dans d'autres cas, les solutions sont un peu plus

compliquées ... et on a besoin d'un schéma un peu plus

sophistiqué...

SCHÉMA GÉNÉRAL

REMARQUES

16

Un algorithme glouton produit des solutions optimales si

les propriétés suivantes sont vérifiées :

1. Propriété du choix glouton : Il existe toujours une

solution optimale qui contient un premier choix glouton

En général on montre que toute solution optimale contient ou

débute par le premier choix glouton.

PREUVE D’OPTIMALITÉ

17

2. Propriété de sous-structure optimale : toute solution

optimale contient une sous-structure optimale

Soit S une solution optimale du problème P contenant le choix C et

le S’ = S\{C} alors S’ est une solution optimale du sous problème

PC résultant du choix C dans le problème P


18


Pour monter que l’algorithme glouton rend toujours une

solution optimale, il faut montrer que les deux

propriétés ( choix glouton et sous-structure

optimale) sont vérifiées.

Pour montrer que l’algorithme glouton ne rend pas

toujours une solution optimale, il suffit de trouver un

contre-exemple.

19



E = {10 , 5, 2, 1}: Algorithme Glouton trouve toujours la

solution optimale?

Choix glouton : la valeur de pièce la plus grande

Si s ≥ 10 toute solution optimale contient au moins

une pièce de 10 c’est le premier choix glouton.

Si s < 10, l’algorithme fait un bon premier choix ( au

plus une pièce 5, au plus deux pièce de 2 et au plus

une pièce de 1)

Toute solution optimale contient donc un choix

glouton

20

Propriété de sous-structure optimale :

Soient S une solution optimale pour la somme s et C S

un choix glouton (la plus grande pièce) alors S’ = S- {C}

est une solution optimale pour s-valeur(C).

1ère Méthode: Preuve par absurde

Supposant que:

H1: S une solution optimale pour la somme s

H2: C S un choix glouton (la plus grande pièce)

H3: S’ = S- {C} est une solution non optimale

pour s-valeur (C)



21

1ère Méthode: Preuve par absurde

Supposant que:

H1: S une solution optimale pour la somme s

H2: C S un choix glouton (la plus grande pièce)

H3: S’ est une solution non optimale pour s-valeur (C)

Alors il existe une solution S’’ meilleure que S’ pour s-

valeur (C), i.e.

Donc, S’’ {C} est meilleure que S’ {C} pour s car

i.e, S = S’ {C} n’est pas optimale (contradiction avec

l’hypothèse H1).



22

E = {8, 4, 2}:

Solution optimale existe si S est pair et S >1

Algorithme Glouton donne la solution optimale si elle

existe

E = {5, 2}:

Solution optimale existe si n 4

Algorithme Glouton ne la trouve pas toujours (n=6)

E = {5, 4, 1}:

Solution optimale existe toujours

Algorithme Glouton trouve toujours la solution mais elle

n’est pas toujours optimale (n=8)



23

Conclusion: Caractériser les jeux de pièces pour lesquels

l’algorithme glouton est optimal est un problème

ouvert. Il est facile de trouver des catégories qui

marchent (par exemple des pièces E ={1,B,B2,B3} pour B ≥

2) mais le cas général résiste !



CHAPITRE V:







ALGORITHMIQUE 02

Cours n°13: 27 Novembre 2013

AROUSSI Sana





25

EXEMPLE 2: ORDONNANCEMENT DES TÂCHES

Soit E= {1,..., n} un ensemble de n tâches.

La tâche i commence à l’instant Di et finit à l’instant Fi.

Deux tâches i, j sont compatibles si elles ne se

chevauchent pas (Dj Fi) .

But 1 : trouver un ensemble maximal de tâches

compatibles.

26


Algorithme glouton: Trier les tâches selon leur date

fin et sélectionner une tâche compatible par ordre

croissant.

E 1 2 3 4 5 6 7 8 9

D 1 2 4 1 5 8 9 13 11

F 8 5 7 3 9 11 10 16 14

27

1. Trier les tâches selon leur date fin 1. Trier les tâches selon leur date fin

2. Sélectionner les tâches compatibles par ordre croissant 2. Sélectionner les tâches compatibles par ordre croissant

Solution: Tâches 4, 3, 7, 9


E 1 2 3 4 5 6 7 8 9

D 1 2 4 1 5 8 9 13 11

F 8 5 7 3 9 11 10 16 14

E 4 2 3 1 5 7 6 9 8

D 1 2 4 1 5 9 8 11 13

F 3 5 7 8 9 10 11 14 16

E 4 2 3 1 5 7 6 9 8

D 1 2 4 1 5 9 8 11 13

F 3 5 7 8 9 10 11 14 16

28


SCHÉMA GLOUTON

Trier (E, D, F) //trier selon ordre croissant de la date fin

S{E[1]}; j1 //Initialiser la solution

i2

Tant que (i n) faire // La solution est complète après

avoir parcouru tous les éléments de E

// La tâche E[i] est sélectionnée

Si D[i] F[j] // Si la tâche E[i] est compatible avec la

tâche E[j]

S S {E[i]} // Ajouter la solution

j i;

i ++

FTQ

29

Premier choix glouton : E[1] est la tâche ayant la

date fin la plus petite

Propriété 1: Il existe toujours une solution

optimale qui contient le premier choix glouton

Soit S = { T1, ..., Tk} une solution optimale ordonnée

(D[T1] < D[T2]<.....<D[Tk]) tel que F[Tk] F[1]

Si T1 E[1] alors S – {T1} contient l’ensemble des

tâches compatibles avec T1 ainsi avec E[1].

Ainsi, S – {T1} {E[1]} est aussi une solution

optimale.



30

Premier choix glouton : E[1] est la tâche ayant la

date fin la plus petite

Propriété 2: Toute solution optimale contient une

sous-structure optimale

Soit S = { T1, ..., Tm} une solution optimale ordonnée

(D[T1] < D[T2]<.....<D[Tk]) alors S – {T1} est aussi

une solution optimale. Le problème se ramène à

trouver une solution optimale des tâches compatibles

avec T1.



31

Preuve par absurde

Supposant que:

H1: S = { T1, ..., Tk} une solution optimale

H2: S’ = S - {T1} est une solution non optimale.

Alors, il existe une solution meilleure (S’’) que S’, i.e.

|S’’| > |S’| = k-1.

Donc, S’’ {T1} est meilleure que S car |S’’ {T1}|> k,

i.e, S n’est pas optimale (contradiction avec

l’hypothèse H1).



32


Soit E= {1,..., n} un ensemble de n tâches.

La tâche j commence à l’instant Di et finit à l’instant Fi.

Chaque tâche est exécutée sur une machine.

Une machine exécute une tâche à la fois.

But 2 : Trouver un nombre minimal de machines

permettant d’exécuter toutes les tâches.

33


Algorithme Glouton: Trier les tâches selon leur date

début et attribuer une machine compatible à chaque

tâche.

E 1 2 3 4 5 6 7 8 9

D 1 2 4 1 5 8 9 13 11

F 8 5 7 3 9 11 10 16 14

34

1. Trier les tâches selon leur date début 1. Trier les tâches selon leur date début

2. Attribuer une machine compatible à chaque tâche 2. Attribuer une machine compatible à chaque tâche

Solution: 3 machines


E 1 4 2 3 5 6 7 9 8

D 1 1 2 4 5 8 9 11 13

F 8 3 5 7 9 11 10 14 16

M 1 2 3 2 3 2 1 3 1

E 1 4 2 3 5 6 7 9 8

D 1 1 2 4 5 8 9 11 13

F 8 3 5 7 9 11 10 14 16

35


SCHÉMA GLOUTON

Trier (E, D, F) //trier selon ordre croissant de la date

début

Soit FP une file prioritaire dans laquelle on garde les

machines. Les machines sont classés par ordre croissant

de la date fin de la tâche attribuée. Ainsi, une machine est

caractérisée par son numéro (Num) et une date fin (Fin).

CréerFile (FP); Nb0 //Initialiser la solution

i1

36


SCHÉMA GLOUTON

Trier (E, D, F) //trier selon ordre croissant de la date début

CréerFile (FP); Nb0; //Initialiser la solution

i1

Tant que (i n) faire

Si (FP = Nil) ou (D[i] < FP.Fin) // Si la file est vide ou la tâche E[i] est

compatible avec la machine FP.Num

NB++ // Ajouter la solution

M.Num NB;

Sinon

Défiler (FP, M);

M.FinF[i]; Enfiler (FP, M)

i ++

FTQ

37

Soit S = { M1, ..., Mk} une solution optimale.

Premier choix glouton : la tâche E[1], ayant la date

début la plus petite, est affectée à la machine M1



La solution optimale contient au moins une machine

(k1), c’est la machine M1.



38

Premier choix glouton : la tâche E[1], ayant la date

début la plus petite, est affectée à la machine M1



Soit S = { M1, ..., Mk} une solution optimale pour E

alors S – {M1} est aussi une solution optimale pour E

- {T(M1)}. T(M1) est l’ensemble des tâches exécutées

sur la machine M1.



39

Preuve par absurde

Supposant que:

H1: S = { M1, ..., Mk} une solution optimale pour E

H2: S’ = S- {M1} est une solution non optimale pour E –

{T(M1)}.

Alors, il existe une solution meilleure (S’’) que S’ pour E

– {T(M1)}, i.e. |S’’| < |S’| = k-1.

Donc, S’’ {M1} est meilleure que S pour E car

|S’’ {T1}| < k, i.e, S n’est pas optimale

(contradiction avec l’hypothèse H1).



40

EXEMPLE 4: PROBLÈME DE SAC À DOS ENTIER

Soit E= {1,..., n} un ensemble de n objets.

Chaque objet i a un poids Pi et une valeur Vi. Il peut

être pris en entier et au plus une fois, i.e. Nbi {0,

1}.

Soit un sac à dos de contenance maximale Pmax

But : Maximiser la valeur totale des objets mis

dans le sac à dos

41


Algorithme Glouton: trier les objets selon un critère

donné et sélectionner un objet jusqu’à atteindre la

capacité maximale de sac à dos.

Choix gloutons possibles

choisir l’objet de plus grande valeur

choisir l’objet le plus léger

choisir l’objet dont le rapport valeur/poids est

maximal.

Montrer que ces choix ne donnent pas de solution

optimale dans le cas où l’objet est pris en entier.

42


E 1 2 3

P 10 20 30

V 30 100 120

V/P 3 5 4

Pmax = 50

(220)

Pmax = 40

(150)

Pmax = 30

(130)

L’objet le plus

léger

Non (130) Non (130) Oui (130)

L’objet de plus

grande valeur

Oui (220) Oui (150) Non (120)

L’objet dont le

rapport V/P est

maximal

Oui (220) Non (130) Oui (130)

CHAPITRE V:







ALGORITHMIQUE 02

Cours n°14: 01 Décembre 2013

AROUSSI Sana





44

EXEMPLE 5: PROBLÈME DE SAC À DOS FRACTIONNÉ

Soit E= {1,..., n} un ensemble de n objets.

Chaque objet i a un poids Pi et une valeur Vi. Il peut

être fractionné i.e. Nbi [0, 1].

Soit un sac à dos de contenance maximale Pmax

But : Maximiser la valeur totale des objets mis

dans le sac à dos

45


E 1 2 3

P 10 20 30

V 30 100 120

V/P 3 5 4

Pmax = 50

(220)

Pmax = 40

(180)

Pmax = 30

(140)

L’objet le plus

léger

Non (210) Non (170) Non (130)

L’objet de plus

grande valeur

Oui (220) Non (170) Non (120)

L’objet dont le

rapport V/P

est maximal

Oui (220) Oui (180) Oui (140)

46

Une solution S = (nb1, ...., nbn) présente le nombre de

l’objet i (nbi [0, 1])

Algorithme glouton: Trier les objets par ordre

décroissant de leur rapport Vi/Pi. Pour chaque objet,

maximiser le nombre nbi [0, 1] jusqu’à atteindre la

capacité maximale de l’objet.


47


SCHÉMA GLOUTON

Trier (E, P, V) //trier selon ordre décroissant du rapport V/P

Init (S) //Initialiser la solution nbi à 0

i1

Tant que (Pmax > 0) et (i n) faire

// Ajouter la solution

Si P[i] Pmax

S[i] 1

Sinon

S[i] Pmax / P[i]

Pmax Pmax – P[i]

i ++

FTQ

48



Soit S = (nb1,..., nbn) une solution optimale.

Premier choix glouton : l’objet E[1], ayant le rapport

V/P le plus grand



49





Cette propriété est toujours vérifiée. En effet, il ne

peut exister que trois cas de figures:

S = (1, 1, ......, 1) si

S = (1, 1, ....., 1, k, 0, ....., 0) si

S = (1, 0, ....., 0) si

50



Soit S = (nb1,..., nbn) une solution optimale.



Soient S une solution optimale pour Pmax, alors S –

{nba} est aussi une solution optimale pour Pmax – Pa.

(Pa = nba x P[a])

51


PREUVE D’OPTIMALITÉ Preuve par absurde

Supposant que:

H1: S = (nb1,..., nbn) une solution optimale pour Pmax

H2: S’ = S- {nba} est une solution non optimale pour Pmax – Pa.

Alors, il existe une solution meilleure (S’’) que S’ pour

Pmax – Pa, i.e. W(S’’) > W(S’). W(K) retourne la valeur

totale de la solution K.

Donc, S’’ {nba} est meilleure que S pour Pmax car

V(S’’ {nba}) > V(S), i.e, S n’est pas optimale


52

EXEMPLE 6: ARBRE RECOUVRANT MINIMAL

Soit G = (X,E, W) un graphe connexe non orienté valué

tel que:

X est l’ensemble de sommet avec |X| = n.

E est l’ensemble des arrêtes avec |E| = m

W est une fonction de valuation des arêtes W: ER

Un arbre recouvrant de G est un sous graphe A

(X, EA, W) connexe et sans cycle. Ainsi, | EA|= n-1.

53


Un Arbre Recouvrant Mimimum ARmin (X,EA) du G est

un arbre recouvrant qui minimise

1. Écrire l’algorithme Glouton.

2. Prouver l’optimalité de l’algorithme

54


Algorithme glouton: Trier les arêtes par ordre croissant

de leur valuation. Sélectionner une arête (si elle forme

pas un cycle avec les arêtes déjà sélectionnées) jusqu’à

construire un arbre recouvrant.

C’est le principe de l’Algorithme de Kruskal

55


SCHÉMA GLOUTON

Trier (E) //trier les arêtes selon ordre croissant de leur poids

Initi (EA)//Initialiser la solution; EA est un tableau à (n-1) éléments

nb0 // le nombre des arêtes sélectionnées

i 1

Tant que (nb n-1) faire

// la fonction Cycle vérifie que l’ensemble des arêtes EA E[i] ne

forment pas un cycle

Si non Cycle (EA , E[i]) alors

nb ++

EA[nb] E[i]

i ++

FTQ

56



Premier choix glouton : l’arête e = E[1], ayant la

valuation la plus petite.



Lemme 1: Soient A est un arbre recouvrant, e

A alors e’ A tel que A – {e’} {e} est un

arbre recourvrant. De plus, e’ peut être choisi

dans le cycle formé par les arêtes de A et e.

57





Soit A la solution optimale.

Si e A alors e’ A tel que A – {e’} {e} est aussi un

arbre recouvrant minimal. En effet

W(A – {e’} {e}) = W (A) - w(e’) + w (e) = W* - w(e’) +

w (e) = W*

Ainsi, w (e) = w (e’), i.e. les deux arêtes possèdent la

même valuation.

58



Soit A* une solution optimale.



Soient A* une solution optimale pour W*, alors A*–

{e} est aussi une solution optimale pour W* - w (e)

Lemme 2: Soient A est un arbre recouvrant

pour G = (X, E) et e = (x, y) A tel que d(y) = 1

alors A – {e} est aussi un arbre pour G = (X – {y},

Ey)

59



Preuve par absurde

Supposant que:

H1: A* une solution optimale pour W*

H2: S’ = S- {e} est une solution non optimale pour W* – w(e).

Alors, il existe une solution meilleure (S’’) que S’ pour

W* – w(e), i.e. W(S’’) < W(S’).

Donc, S’’ {e} est meilleure que S pour Pmax car

V(S’’ {nba}) > V(S), i.e, S n’est pas optimale


SOURCES DE CE COURS

Sophie Tison, Algorithmes Gloutons (greedy algorithms), Cours Master Informatique

1ère année, Université Lille 1.

Chapitre 4 Algorithmes Gloutons, Cours MACS (Mathématiques Appliquées et Calcul

Scientifique), Disponible sur www.lamacs.fr/documents/cours/macs1/infochap4.pdf‎

Stéphane Grandcolas, Algorithmes gloutons. Disponible sur www.dil.univ-

mrs.fr/~gcolas/algo-licence/slides/gloutons.pdf‎

Yves Robert, Yves Caniou et Eric Thierry. Algorithmique - Cours et Travaux Dirigés,

École Normale Supérieure de Lyon, 2005.

Ana Busic, Algorithmes Gloutons, Conception d'algorithmes et applications, École

normale supérieure, Département Informatique, Disponible sur

www.di.ens.fr/~busic/cours/LI325/slidesCAAC8_1213.pdf‎

Robert Cori, Analyse et Conception Algorithmes 1, Algorithmes gloutons, Disponible

sur www.lix.polytechnique.fr/~cori/Majeure/cours1.pdf‎

60

Education

Chapitre v algorithmes gloutons