Les algorithmes voraces - UQAC

The Chesapeake Bay Watershed

8INF430 Algorithmes voraces 4✬✩Définition: La matrice L donne la longueur de l’arc entre chaquepair de noeuds. Si l’arc entre les noeuds i et j est absent alors on aL[i, j] = ∞.fonction Dijkstra(L[1..n,1..n])S={1}pour i=1 à n faireD[i]=L[1,i]répéter n-2 foischoisir v dans N-S tel que D[v] est minimalajouter v à Spour chaque w successeur de v faireD[w]=min{D[w],D[v]+L[v,w]}retourner D✫✪

8INF430 Algorithmes voraces 6✬✩Théorème:Rectitude de l’algorithme(a) Si un noeud i ≠ 1 est dans S alors D[i] donne la longueur duplus court chemin entre 1 et i.(b) Si un noeud i n’est pas dans S alors D[i] donne la longueur duplus court chemin spécial entre 1 et i.Preuve. (par induction mathématique)Base: S = {1}Hypothèse d’induction: Les deux conditions sont vraies justeavant d’ajouter le noeud v à S.✫✪

8INF430 Algorithmes voraces 8✬✩xsourcev✫✪

8INF430 Algorithmes voraces 9✬✩Pas d’induction pour la condition (b)Il y a deux cas:1. Le plus court chemin spécial de 1 à w ne passe pas par v etdonc reste D[w] ou2. Le plus court chemin spécial de 1 à w passe par v:2.1 v est le noeud qui précède w2.2 x ≠ v est le noeud qui précède w✫✪

8INF430 Algorithmes voraces 10✬✩On doit avoir v = x car sinon on aurait choisis v avant x.sourcevxw✫✪

8INF430 Algorithmes voraces 11✬✩Analyse de l’algorithme de DijkstraLe temps est fonction du nombre de noeuds et d’arêtes: T (a, n)Il y a deux structures de données à considérer:• graphe L (matrice ou listes d’adjacence)• file de priorité D (tableau ou monceau)✫✪

8INF430 Algorithmes voraces 12✬✩Complexité des opérations sur la file de prioritétableau monceauconstruire O(1) O(n)trouver O(n) O(lg n)enlever O(1) O(lg n)ajouter O(1) O(lg n)modifier O(1) O(lg n)✫✪

8INF430 Algorithmes voraces 13✬✩Temps d’exécutionD tableau monceauL matrice listes d’adjacenceT (a, n) O(n 2 ) O((n + a) lg n)graphe dense O(n 2 ) O(n 2 lg n)graphe claisemé O(n 2 ) O(n lg n)Remarque: Si le graphe est réprésenté sous la forme de listesd’adjacence et que D est un monceau alors le temps total passé àexécuter la dernière boucle pour sera dans Θ(a log n) où a est lenombre d’arcs.✫✪

8INF430 Algorithmes voraces 14✬✩Généralisation de l’algorithme de DijkstraL’algorithme de Dijkstra est utile lorsque l’on ne possède aucuneinformation particulière sur le graphe.En pratique, ce n’est pas le cas.Considérer par exemple, un service Internet, tel que MapQuest, quicalcule le meilleur itinéraire entre deux villes. Il est possible dedonner une approximation du temps nécessaire en utilisant ladistance (à vol d’oiseau) entre les deux villes.On peut alors ignorer les villes qui nous éloignent trop de notredestination.✫✪

8INF430 Algorithmes voraces 15✬Péribonka✩St-FélicienAlmaRobervalChicoutimiJoncquièreLa BaieSaint SiméonLa TuqueBaie Saint PaulShawiniganQuébecTrois RivièreDrumondvilleMontréal✫Sherbrooke✪

8INF430 Algorithmes voraces 16✬✩Chemin le plus court entre deux noeudsSoit un graphe G = (N, A) tel que N = {1, 2, . . . , n}. On cherche leplus court chemin de 1 à n.On suppose l’existence d’une fonction h : N → R tel que h(i) estune approximation de la distance entre i et n.On suppose aussi que h ne surestime jamais la distance. End’autres mots, h(i) est plus petit ou égal à la longueur du pluscourt chemin entre i et n.✫✪

8INF430 Algorithmes voraces 17✬✩Algorithme A ∗fonction A*(L[1..n,1..n])S={1}pour i=1 à n faire D[i]=L[1,i]répéterchoisir v dans N-S t.q. D[v]+h(v) est minimalsi (v=n) alors retourner D[n]ajouter v à Spour chaque w successeur de v fairesi (D[w] > D[v]+L[v,w]) alorsD[w] = D[v]+L[v,w]enlever w de S (s’il s’y trouve)✫✪

8INF430 Algorithmes voraces 18✬✩RemarquesL’algorithme de Dijkstra est le cas particulier où h(n) = 0 pourtous n ∈ N.Dans l’algorithme de Dijkstra, tous les noeuds w ∈ S sont tels queD[w] est minimal. On ne peut donc jamais diminuer D[w] etl’instruction “enlever w de S” est inutile.Problème: Modifiez l’algorithme A ∗ pour qu’il retourne le pluscourt chemin plutôt que sa longueur.✫✪

8INF430 Algorithmes voraces 19✬✩Code d’HuffmanProblème: Sauvegarder un fichier en utilisant le moins d’espacepossible.Idée: On lit le fichier 2 fois1. On calcule la fréquence de chaque caractère2. On encode chaque caractère en binaire: Code court pour lescaractères apparaissant le plus souvent.✫✪

8INF430 Algorithmes voraces 20✬✩Exemple. Fichier de 100000 caractères (6 caractères distincts)Caractère a b c d e fFréquence 45 13 12 16 9 5Code fixe 000 001 010 011 100 101Code variable 0 101 100 111 1101 1100✫✪

8INF430 Algorithmes voraces 21✬Encoder abc:✩Code fixe:000}{{}001}{{}010}{{}a b cCode variable:0}{{}101}{{}100}{{}a b cTaille du fichier encodé:Code fixe: 3 ∗ 10000 = 300000 bitsCode variable: 1 ∗ 45000 + 3 ∗ 13000 + 3 ∗ 12000+3 ∗ 16000 + 4 ∗ 5000= 224000 bits✫✪

8INF430 Algorithmes voraces 22✬Code préfixe✩Code dont l’encodage d’un caractère n’est le préfixe d’aucun autre.Exemple: Le code suivant n’est pas préfixea → 10b → 1011• Simplifie l’encodage: concaténation• Simplifie le décodage: pas d’ambiguïtéExemple:0010111010 0 101 1101a a b e✫✪

8INF430 Algorithmes voraces 23✬Un code préfixe peut toujours être représenté à l’aide d’un arbrebinaire.Si l’arbre n’est pas complet alors le code n’est pas optimal.✩a: 000b: 001c: 010d: 011e: 100f: 101✫✪

8INF430 Algorithmes voraces 24✬✩En général:• Alphabet ALa profondeur d’un caractère=la longueur de l’encodage de ce caractère• f(c) dénote la fréquence du caractère c ∈ A• d T (c) dénote la profondeur du caractère c dans l’arbre TLe nombre de bits requis pour encoder le fichier à l’aide de T estappelé le coût de T et défini par:coût(T ) = ∑c∈Af(c)d T (c)✫✪

8INF430 Algorithmes voraces 25✬✩Construire un code d’HuffmanExemple:a)f: 5 e: 9 c: 12 b: 13 d: 16 a: 45b)c: 12 b: 1314d: 16a: 45f: 5e: 9✫✪

8INF430 Algorithmes voraces 26✬✩c)d: 161425a: 45f: 5e: 9c: 12b: 13d)2530a: 45c: 12b: 1314d: 16f: 5e: 9✫✪

8INF430 Algorithmes voraces 27✬✩e)a: 45552530c: 12b: 1314d: 16f: 5e: 9✫✪

8INF430 Algorithmes voraces 28✬f)✩100a: 45552530c: 12b: 1314d: 16f: 5e: 9✫✪

8INF430 Algorithmes voraces 29✬✩ImplémentationRappel: File de priorité• Structure de données permettant de manipuler un ensembleQ = {x 1 , x 2 , ..., x n }• x i :valeurfréquencegauche droite✫✪

8INF430 Algorithmes voraces 30✬✩• Opérations:1. Q=créer file(A) O(n)2. insérer(Q,x) O(lg n)3. m=extraire min(Q) O(lg n)4. x=creer element() O(1)5. v=valeur(x) O(1)6. f=frequence(x) O(1)7. xd=droite(x) O(1)8. xg=gauche(x) O(1)✫✪

8INF430 Algorithmes voraces 31✬✩ExempleA = {[a, 45], [b, 13], [c, 12], [d, 16], [e, 9], [f, 5]}✫✪

8INF430 Algorithmes voraces 32✬Algorithme✩A est un alphabet contenant n caractèresOn associe à chaque caractère c une valeur f(c)Huffman(A,n)Q=creer_file(A,n)pour i=1 à n-1 fairez=creer_element()x=gauche(z)=extraire_min(Q)y=droite(z)=extraire_min(Q)f(z)=f(x)+f(y)inserer(Q,z)retourner extraire_min(Q)Temps d’exécution: O(n lg n)✫✪

8INF430 Algorithmes voraces 33✬✩Optimalité de la construction• x: le caractère ayant la moins grande fréquence• y: le caractère ayant la seconde moins grande fréquenceFait 1: x et y doivent être à une profondeur maximaleFait 2:SPDG x et y ont le même père✫✪

8INF430 Algorithmes voraces 34✬Exemple pour 1✩c: 12010 1b: 13 a: 45128000a: 45010 1b: 13 c: 1295000✫✪

8INF430 Algorithmes voraces 35✬✩Fait 3: Si on remplace x et y par un nouveau caractère z ayantune fréquencef(z) = f(x) + f(y)alors le nouvel arbre représente un code optimal pourA − {x, y} ∪ {z}✫✪

8INF430 Algorithmes voraces 36✬✩Exemple 2TT‘14z: 14x: 5 y: 9✫✪

8INF430 Algorithmes voraces 37✬✩Arbre couvrant minimalEntrée: Un graphe G = 〈N, A〉 où chaque arête a ∈ A a unelongueur positive l(a).Problème: Trouver un sous-ensemble T ⊆ A, tel que le graphedemeure connecté si seules les arêtes dans T sont utilisées. De plus,on doit minimiser ∑ l(x).x∈TFait: T doit être un arbre.✫✪

8INF430 Algorithmes voraces 38✬✩Algorithme de Kruskal1. Trier les arêtes en ordre croissant2. Choisir la prochaine arête qui ne crée par de cycle avec cellesdéjà choisies.✫✪

8INF430 Algorithmes voraces 39✬✩1 21 2 346 54 63 84 5 674 37{1}{2}{3}{4}{5}{6}{7}(1, 2) 1 {1, 2}{3}{4}{5}{6}{7}(2, 3) 2 {1, 2, 3}{4}{5}{6}{7}(4, 5) 3 {1, 2, 3}{4, 5}{6}{7}(6, 7) 3 {1, 2, 3}{4, 5}{6, 7}(1, 4) 4 {1, 2, 3, 4, 5}{6, 7}(2, 5) 4 X(4, 7) 4 {1, 2, 3, 4, 5, 6, 7}✫✪

8INF430 Algorithmes voraces 40✬Structure d’ensembles disjoints✩• N objets numérotés de 1 à N• On veut regrouper ces objets en un certains nombred’ensembles disjoints.• Dans chaque ensemble, on choisi un objet pour servir dereprésentant• 2 sortes d’opérations✫1. representant( a): retourne le représentant de l’ensemblecontenant a2. fusionner( a, b): fusionne les deux ensembles contenant a etb, retourne un représentant pour le nouvel ensemble.✪

8INF430 Algorithmes voraces 41✬✩Chaque ensemble est représenté par un arbre inversé:64 911 112 20 25✫✪

8INF430 Algorithmes voraces 42✬fonction representant(x)i=xtantque père[i] != i fairei=père[i]retourner i✩✫// a et b sont des représentant distinctsprocedure fusion(a,b)si hauteur[a]=hauteur[b] alorshauteur[a]=hauteur[a]+1père[b]=asinonsi hauteur[a]> hauteur[b] alorspère[b]=asinonpère[a]=b✪

8INF430 Algorithmes voraces 43✬✩Exemple 1:614 912 20 251612 20 254 9✫✪

8INF430 Algorithmes voraces 44✬Exemple 2:✩614 912 20 2571612 20 254 97✫✪

8INF430 Algorithmes voraces 45✬Analyse de la structure d’ensembles disjoints✩Noeuds:pèrehauteurinformationInitialisation: père[a]=a et hauteur[a]=0Proposition: Après une séquence arbitraire d’opérations fusion àpartir de la situation initiale, un arbre a contenant k noeuds auraune hauteur d’au plus ⌊lg k⌋.Corollaire: Le temps requis pour effectuer une séquence arbitrairede n opérations representant et fusion est dans O(n lg n)en pire cas.✫✪

8INF430 Algorithmes voraces 46✬Preuve par induction de la proposition✩Trivial si l’arbre a contient k = 1 noeud.Supposons que l’arbre a contient k > 1 noeuds.L’abre a est construit à partir de 2 sous-arbres b et c :• b contient i noeuds et hauteur[i] ≤ lg i (hypothèse d’induction)• c contient j noeuds et hauteur[j] ≤ lg j (hypothèse d’induction)• i + j = k et SPDG i ≤ jSi i < j alorshauteur[a] = hauteur[c]≤ lg j ≤ lg kSi i = j alorshauteur[a] =1+hauteur[c]≤ 1 + lg j = lg(2j) = lg k✫✪

8INF430 Algorithmes voraces 47✬✩Algorithme de Kruskalfonction Kruskal(G=(N,A))Trier A en ordre croissantT={}Initialiser n ensemblesTantque |T|< n-1 faire(u,v)=prochaine ar^eteurep=representant(u)vrep=representant(v)si urep != vrep alorsfusion(urep,vrep)ajouter (u,v) à T✫✪

8INF430 Algorithmes voraces 48✬Analyse✩On peut trier un ensemble de k éléments en temps O(k lg k)Le temps pour trier est dans O(|A| lg |A|) = O(|A| lg n)puisque |A| ≤ n(n − 1)/2Initialisation: O(n)Boucle tant que: Au plus |A| itérations=⇒ une séquence d’au plus 3|A| opérations representant etfusion=⇒ O(|A| log n)T (n) ∈ O(|A| lg n)✫✪