Dati e Algoritmi 1: A. Pietracaprina. Priority Queue (I Parte)

Transcript

1 Dati e Algoritmi 1: A. Pietracaprina Priority Queue (I Parte) 1

2 Nozione di Entry Definizione Una Entry è una coppia (chiave, valore), dove la chiave proviene da un dominio K e il valore da un dominio V. Interfaccia: public interface Entry<K,V> { /** Returns the key of the entry */ K getkey(); /** Returns the value of the entry */ V getvalue(); } 2

3 Priority Queue Definizione Priority Queue: collezione di entry le cui chiavi (non necessariamente distinte) rappresentano priorità e provengono da un universo totalmente ordinato K. Come tipo di dato astratto, la Priority Queue deve permettere di Trovare ed eventualmente rimuovere la entry di massima priorità. Inserire una nuova entry. Osservazioni: Di solito si assume che la entry di massima priorità sia quella con chiave minima. Esistono però dei casi in cui conviene considerare di massima priorità la entry con chiave massima. Come vedremo mantenere le entry ordinate permette di indetificare immediatamente la entry di massima priorità, ma non è la scelta imple,entativa migliore. 3

4 Priority Queue: interfaccia public interface PriorityQueue<K,V> { int size(); boolean isempty(); /** Inserts and returns a new entry (key,value) */ Entry<K,V> insert(k key, V value); /** Returns an entry with min key, without removing it */ Entry<K,V> min(); /** Returns and removes an entry with min key */ Entry<K,V> removemin(); } 4

5 Esempio Partiamo da Priority Queue vuota Operazione Output Priority Queue insert(5,a) (5,A) (5,A) insert(9,c) (9,C) (5,A) (9,C) insert(3,b) (3,B) (5,A) (9,C) (3,B) insert(7,d) (7,D) (5,A) (9,C) (3,B) (7,D) min() (3,B) (5,A) (9,C) (3,B) (7,D) removemin() (3,B) (5,A) (9,C) (7,D) size() 3 (5,A) (9,C) (7,D) isempty() false (5,A) (9,C) (7,D) 5

6 Applicazioni delle priority queue Gestione liste d attesa (ad es. aeroporti) Scheduling di processi in sistema operativo o di richieste di banda nelle reti in base a priorità per garantire QoS Simulazione discreta a eventi Dijkstra: algoritmo per Single Source Shortest Path Top-K pattern discovery (vedi lucidi seguenti) 6

7 Top-K pattern discovery Dato uno stream S[1], S[2],..., S[n] di n entry con chiavi distinte (n grande!) che arrivano in sequenza una dopo l altra, si vogliono determinare le K << n entry con chiave più grande senza salvare tutte le entry ma usando spazio indipendente da n. È una primitva fondamentale per l analisi di dati in molti domini applicativi (ad es., biologia, recommendation systems, astronomy, fraud detection, ecc.) È POSSIBILE USARE UNA CODA CON PRIORITÀ? 7

8 Top-K pattern discovery (continua) Idea: Usare una priority queue Q di appoggio per mantenere il seguente invariante: dopo l arrivo delle prime i entry (S[1],..., S[i]), la priority queue Q contiene le min{i, K} entry con chiave maggiore tra esse. Algoritmo streamtop(s,k) Input: Stream S di n entry, intero K << n Output: K entry di S con chiave più grande Q priority queue vuota; for i 1 to n do if i K then Q.insert(S[i].getKey(),S[i].getValue()); else if S[i].getKey() > Q.min().getKey() then Q.removeMin(); Q.insert(S[i].getKey(),S[i].getValue()); return Q Esercizio Dimostrare la correttezza di streamtop 8

9 Implementazione di Priority Queue tramite Liste Caso 1: Lista doubly linked non ordinata P lista non ordinata di n entry (Position<Entry< K, V >>) Implementazione dei metodi della Priority Queue: Metodo min() Complessità = Θ (n) v P.first(); minentry v.getelement(); while (P.after(v) null) do v P.after(v); if (v.getelement().getkey() < minentry.getkey()) then minentry v.getelement(); return minentry 9

10 Implementazione di Priority Queue tramite Liste Caso 1: Lista doubly linked non ordinata (continua) 10 Metodo insert(k, x) Complessità = Θ (1) e (k, x); P.addLast(e); return e Metodo removemin() Complessità = Θ (n) (esercizio)

11 Implementazione di Priority Queue tramite liste Caso 2: Lista doubly linked ordinata 11 P lista ordinata di n entry (Position<Entry< K, V >>) N.B. Si assume un ordinamento per chiave crescente Metodo min() Complessità = Θ (1) return P.first().getElement() Metodo removemin() Complessità = Θ (1) (esercizio)

12 Implementazione di Priority Queue tramite Lista ordinata doubly linked (continua) 12 Metodo insert(k, x) Complessità = Θ (n) e (k, x); v P.first(); while v null do if (v.getelement().getkey() k) then P.addBefore(v,e); return e else v P.after(v) P.insertLast(e); return e

13 Priority Queue tramite Liste: riepilogo 13 1 Lista non ordinata doubly-linked i nodi della lista contengono entry P.insert(k,x): complessità Θ (1) P.min(), P.removeMin(): complessità Θ (n) 2 Lista ordinata doubly-linked i nodi della lista contengono entry ordinate per chiave P.insert(k,x): complessità Θ (n) P.min(), P.removeMin(): complessità Θ (1) È possibile bilanciare il costo delle diverse operazioni?

14 14 Albero Binario Completo T Albero binario di altezza h tale che i, 0 i h 1: il livello i ha 2 i nodi (=max numero di nodi) al livello h 1 tutti i nodi interni sono alla sx delle eventuali foglie e hanno tutti 2 figli tranne, eventualmente, quello più a dx che può avere il solo figlio sx. livello& 0& 1& 2& 3& h=4&

15 15 Proposizione Un albero binario completo con n nodi ha altezza h = log 2 n. Dimostrazione Si ha che h 1 2 h = j n j=0 h 2 j = 2 h+1 1 j=0 h log n < h + 1 (log 2 n) 1 < h log 2 n

16 Heap 16 Definizione Uno heap è un albero binario completo i cui nodi memorizzano entry e soddisfano la seguente heap-order property: <k 1#,x># k 1 min{k 2, k 3 } <k 2#,y># <k 3#,z># Esempio <2 ",A># <5 ",C># <9 ",D># <7 ",H># <6 ",N>#

17 17 Nota Uno heap è caratterizzato da 2 proprietà: albero binario completo altezza Θ (log n) heap-order property min() in O (1) Definizione Nodo Last in uno heap di altezza h: nodo più a dx al livello h. Esempio <2 ",A># <5 ",C># <9 ",D># Last% <7 ",H># <6 ",N>#

18 Proprieta di uno heap 1 La radice contiene una entry con chiave minima. <min%key!,x>% 2 heap = mucchio le chiavi incontrate lungo un cammino dalla radice verso le foglie formano una sequenza non decrescente Definizione Max-heap: uno heap nella cui definizione 18

19 19 Esercizio Sia P uno heap con n entry. Risolvere i seguenti punti. 1 (Chiavi distinte) e i entry con l i-esima chiave più piccola (e 1 min()). Dimostrare che se e i è a profondità p allora p < i. 2 (Chiavi distinte) e max entry con chiave massima ( e n ). Dire dove sta e max. (R-9.10 [GTG14]) 3 Sia e v la entry nel nodo v di P. Dimostrare che u T v : e u.getkey() e v.getkey().

20 Svolgimento 20 1 e i entry con l i-esima chiave più piccola e 1 =r! e i! profondita`%p% %p%entry-con-chiave-piu`-piccola-di%e i% p < i 2 e max sta in una foglia. Se fosse in un nodo interno, tale nodo avrebbe un nodo figlio con chiave maggiore di e max.key(), quindi e max non sarebbe l entry con chiave massima assurdo. (N.B.: Esempio di dimostrazione per assurdo)

21 21 3 nodo v con entry e v (entry)!e v! v!(nodo)* e 1! w 1! ek! wk! e u! u! e v.getkey() e 1.getKey() e k.getkey() e u.getkey()

22 Realizzazione di uno heap tramite array 22 Level Numbering Entry radice P[1] Entry figlie di P[i]: P[2i] P[2i + 1] Entry padre di P[i] = P [ i/2 ] Oss. In [GTG14, Par ] il level numbering inizia da 0

23 Realizzazione di uno Heap tramite array (continua) 23 Osservazione: La realizzazione tramite array riduce lo spazio occupato rappresentando implicitamente i link padre-figlio (struttura dati implicita). Notazione (per pseudocodice) P[i] entry: P[i].getKey() P[i].getValue() P[last] entry più a dx al livello h

24 Proprietà del level numbering 24 Per ogni albero binario completo con n 1 nodi e altezza h mappato su un array P tramite level numbering, valgono le seguenti proprietà: i, 0 i < h: i 2 i nodi del livello i presi da sx a dx sono mappati in P[j] con 2 i j 2 i+1 1 i nodi del livello h presi da sx a dx sono mappati in P[j] con 2 h j n ( last = n)

25 Proprietà del level numbering (continua) 25 Dimostrazione Per induzione su n 1 (altezza h univocamente determinata da n) base: n = 1 OK passo induttivo: fissiamo n 1 e assumiamo (hp. induttiva) che le proprietà indicate sopra valgano per ogni albero binario completo con n nodi mappato su un array con level numbering. Consideriamo un albero binario completo con n + 1 nodi mappato su un array P con level numbering. L albero è può essere visto come un albero binario completo con n nodi a cui è aggiunto un nodo (P[n + 1]).

26 Dimostrazione (continua) Caso 1: n pari livello& h"1$ h$ nodo$interno$piu`$ a$dx$a$livello$h(1* P[n]$ Caso 2: n dispari, n 2 h+1 1 livello& h"1$ nodo$piu`$a$dx$ al$livello*h* P[(n"1)/2]$ P[n/2]$ Albero$bin.$completo$ con$n+1$nodi$ha$questo$ nodo$in$piu`,$che$viene$ mappato$in$p[n+1]$ P[(n+1)/2]$ h$ P[n]$ $P[n+1]$ Caso 3: n = 2 h+1 1 Livello h completo. Il prossimo nodo sarà P[n + 1] = P[2 h+1 ] figlio di P[2 h ] (nodo più a sx a livello h) 26

27 Esercizio Sia P un array di n entry P[1]P[2]... P[n] le cui chiavi sono in ordine non decrescente. P rappresenta uno heap? Motivare la risposta. Deve soddisfare due proprietà: Svolgimento albero binario completo OK heap-order property P[i]" k" P[2i]" k " k " P[2i+1]" grazie all ordinamento k k e k k OK 27

28 Esercizio (R-9.15 [GTG14]) Si consideri uno heap P con 7 entry con chiavi distinte. 1 È possibile che la visita in preorder restituisca le entry in ordine crescente? (Far vedere un esempio o dimostrare che non è possibile) 2 Ripetere il punto sopra per la visita inorder e postorder. 1 Si! Svolgimento No: Nella visita inorder P[1] (che ha la chiave minima) appare in posizione 4, e in quella in postorder appare in ultima posizione. 28

29 Implementazione di una Priority Queue tramite heap 29 Dobbiamo implementare i metodi dell interfaccia PriorityQueue size() O (1) (banale) isempty() O (1) (banale) min() O (1) (banale: return P[1]) insert(k, x)?? removemin()??

30 Inserimento: insert Idea inserisci la nuova entry alla destra del nodo last ricostruisci la heap-order property dello heap lungo il cammino da last alla radice Metodo insert(k,x) e (k,x); P[+ + last] e; i last; // Up-heap bubbling while ((i > 1)AND(P[ i/2 ].getkey()> P[i].getKey())) do swap( P[i], P[ i/2 ]); i i/2 ; return e; Oss. In caso di overflow, si devono prima trasferire le entry in un array più capiente (ad es. di taglia doppia) 30

31 Esempio (solo chiavi)

32 Esempio (continua) 32 4 insert(8,*)

33

34 34 4 insert(2,*)

35 35 4 insert(2,*)

36 36 4 insert(2,*)

37 37 2 insert(2,*)

38

39 Correttezza di insert 39 Basata sul seguente invariante per il while Invariante Le uniche coppie (u,v) con u antenato di v tali che chiave(u) > chiave(v), se esistono, sono coppie con v = P[i] u! v"="p[i]! N.B. La struttura di albero binario completo non è mai violata P[last]! Esercizio Dimostrare che l invariante vale all inizio del while, e alla fine di ciascuna sua iterazione.

40 Complessità di insert 40 Consideriamo l esecuzione di insert su uno heap P con n entry, e sia h = log 2 (n + 1) l altezza risultante dopo l inserimento. Complessità proporzionale al numero di iterazioni del while Numero di iterazioni del while h Esiste un istanza che richiede esattamente h iterazioni (si inserisce una entry con chiave minore di tutte quelle presenti) Complessità di insert: Θ (log n) Osservazione Se usiamo un array estendibile, in certi casi l inserimento di un nuovo elemento comporta l estensione dell array. Il costo di questa operazione può però essere ammortizzato dalle precedenti invocazioni di insert.

41 Rimozione: removemin 41 Idea rimuovi la entry presente nella radice dello heap metti la entry del nodo Last nella radice ricostruisci la heap-order property dello heap a partire dalla radice verso le foglie

42 42 Metodo removemin() minentry P[1]; P[1] P[last ]; i 1; if 2i last then j indice del figlio di P[i] con chiave min; // j = 2i o j = 2i + 1 // Down-heap bubbling while (2i last)and(p[i].getkey()>p[j].getkey()) do swap(p[i],p[j]); i j; if 2i last then j indice del figlio di P[i] con chiave min; return minentry

43 Esempio (solo chiavi) 43 4" 5" 6" 15" 9" 7" 20" 16" 25" 14" 12" 11" 13"

44 44 13# removemin()# minentry=#4# 5" 6" 15" 9" 7" 20" 16" 25" 14" 12" 11"

45 45 5" removemin()" minentry="4" 13" 6" 15" 9" 7" 20" 16" 25" 14" 12" 11"

46 46 5" removemin()" minentry="4" 9" 6" 15" 13" 7" 20" 16" 25" 14" 12" 11"

47 47 5" removemin()" minentry="4" 9" 6" 15" 12" 7" 20" 16" 25" 14" 13" 11"

48 Correttezza di removemin 48 Basata sul seguente invariante per il while Invariante P[j] figlio di P[i] con chiave minima (se P[i] è interno) uniche coppie (u,v) con u antenato di v tali che chiave(u) > chiave(v), se estistono, sono coppie con u = P[i]. Esercizio Dimostrare che l invariante vale all inizio del while, e alla fine di ciascuna sua iterazione.

49 Complessità di removemin 49 Consideriamo l esecuzione di removemin su uno heap P con n entry, e sia h = log 2 (n 1) l altezza risultante dopo la rimozione. Complessità proporzionale al numero di iterazioni del while Numero di iterazioni del while h Esiste un istanza che richiede esattamente h iterazioni (la entry in P[last] ha chiave maggiore di tutte quelle presenti) Complessità di removemin: Θ (log n)

50 Esempio 2" 4" 5" 15" 9" 7" 6" 16" 25" 14" 12" 11" 8" 20" removemin()+ 4" 9" 5" 15" 12" 7" 6" 16" 25" 14" 20" 11" 8" 50

51 Esempio (2) 4" 9" 5" 15" 12" 7" 6" 16" 25" 14" 20" 11" 8" removemin()+ 5" 9" 6" 15" 12" 7" 8" 16" 25" 14" 20" 11" 51

52 Esempio (3) 5" 9" 6" 15" 12" 7" 8" 16" 25" 14" 20" 11" insert(3,*), 3" 9" 5" 15" 12" 6" 8" 16" 25" 14" 20" 11" 7" 52

53 Esempio (4) 3" 9" 5" 15" 12" 6" 8" 16" 25" 14" 20" 11" 7" insert(4,*), 3" 9" 4" 15" 12" 6" 5" 16" 25" 14" 20" 11" 7" 8" 53

54 Riepilogo: Priority Queue tramite heap 54 Heap albero binario completo altezza log 2 n heap-order property Mapping efficiente su array P[1 n] (level numbering) I collegamenti padre-figlio sono rappresentati implicitamente (struttura dati implicita). Complessità dei metodi: min(): Θ (1) insert(k,v): Θ (log n) (up-heap bubbling) removemin(): Θ (log n) (down-heap bubbling) N.B. Chiavi duplicate sono ammesse

55 55 Caso di studio 3: Simulazione Discreta a Eventi Esempio: ufficio postale 3 categorie di utenti: A, B, C 5 sportelli multifunzione Sportelli # #A 3 #A 2 #A 1# S 1# S 2# #B 3 #B 2 #B 1# S 3# uscita # #C 3 #C 2 #C 1# S 4# S 5# X A, X B, X C : tempi di interarrivo (variabili aleatorie) O A, O B, O C : tempi operativi (variabili aleatorie) ogni utente sceglie lo sportello con meno persone

56 56 A 1# B 1# S 1# S 2# Caso di studio 3: Simulazione Discreta S 3# a Eventi uscita (continua) # Eventi simulati: #C ingressi (A i, B i, C i S) e uscite (Āi, B 3 #C 2 #C 1# 4# i, Ci ), mantenuti in una priority queue Q S 5# A 1# B 1# B 2# C 1# A 2# C 1# B 1# B 3# A 1# C 2# B 3# B 4# A 3# A 2# C 3# B 2# C 3# C 2# asse$temporale$ t# Al tempo t in Q (in ordine di priorità) ho: B 3 Ā 1 C 2 A 3 Ā 2 B 2 che sono stati generati nel seguente ordine: Ā 1 B 3 B 2 C 2 A 3 Ā 2 Simulazione = ciclo di estrazioni e inserzioni da/in Q La rimozione di A i dalla coda fa inserire A i+1 e Āi e incrementare il tempo di attesa allo sportello scelto. Invece, la rimozione di Ā i fa decrementare il tempo di attesa allo sportello. Idem per B i e C i

57 57 Esercizio Progettare e analizzare un algoritmo per rimuovere da uno heap P con n entry la entry P[j] (1 j n), ripristinando poi le proprietà dello heap. Idea: Svolgimento P[j] P[last ] ripristina le proprietà dell heap P[j]! P[last]!

58 58 P[(!j/2"(]=(e 0( =(<k 0(,v 0 > ( P[j]( (e=p[last]( e=<k,v>( Tre casi: P[2j]=e 1( 1. k 0 k min{k 1, k 2 } OK P[2j+1]=e 2( 2. k < k 0 ( k < min{k 1, k 2 }) up-heap bubbling a partire da P[j] e i =<k i(,v i( >(,(i=1,2( N.B. Siamo nella condizione in cui uniche coppie discendente-antenato che violano heap-order property sono P[j],P[l] con P[l] antenato di P[j] 3. k > min{k 1, k 2 } ( k > k 0 ) down-heap bubbling a partire da P[j] N.B. Siamo nella condizione in cui uniche coppie discendente-antenato che violano heap-order prop. sono P[j],P[l] con P[l] discendente di P[j]

59 59 Algoritmo removeentry(p,j) Input: Heap P con n= last entry, j : 1 j n Output: Heap P con n 1 entry ottenuto rimuovendo P[j] P[j] P[last ]; /* Caso2: up-heap bubbling a partire da P[j] */ while j > 1 and P[j].getKey()< P[ j/2 ].getkey() do swap (P[j], P[ j/2 ] ); j j/2 ; if 2j last then i indice figlio di P[j] con chiave minima; /* Caso 3: down-heap bubbling a partire da P[j] */ while 2j last and P[j].getKey()> P[i].getKey() do swap (P[j], P[i] ); j i; if 2j last then i indice figlio di P[j] con chiave minima; Osservazione: il Caso 1 si ha quando nessuno dei due cicli while viene eseguito

60 60 Complessità: Ripetendo l analisi dei metodi insert e removemin si vede che ciascun ciclo while esegue O (log n) iterazioni. Esiste un istanza per la quale il secondo ciclo while esegue Ω (log n) iterazioni (j = 1 e P[last] che contiene la entry con chiave massima) Complessità:Θ (log n)

61 Esempio (solo chiavi) 61 3" 7" 4" 20" 9" 8" 13" 22" 23" 10" 11" 21" Rimuovi"P[2]%

62 62 3" 7" 4" 20" 9" 8" 13" 22" 23" 10" 11" 21" Rimuovi"P[2]%

63 63 Caso"3# 3" 21# 4" 20" 9" 8" 13" 22" 23" 10" 11"

64 64 3" 9" 4" 20" 10" 8" 13" 22" 23" 21" 11"

65 65 3" 9" 4" 20" 10" 8" 13" 22" 23" 21" 11" Rimuovi"P[8]%

66 66 Caso"2" 3" 9" 4" 20" 10" 8" 13" 11" 23" 21"

67 67 3" 9" 4" 11" 10" 8" 13" 20" 23" 21"

68 68 Esercizio (C-9.34 [GTG14]) Progettare un algoritmo che dato uno heap T con n entry e una chiave k stampi tutte le entry in T con chiave k. La complessità deve essere proporzionale al numero di entry stampate (+1 nel caso siano 0). Svolgimento Soluzione Banale Invocare removemin() sino a quando T [1].getKey() k. Se m è il numero di entry stampate, la complessità è O (m log n). Non è difficile trovare un istanza per cui la complessità di questa strategia sia Θ (m log n). Possiamo fare meglio?

69 69 Soluzione migliore Idea: Le entry con chiave k formano un sottoalbero T (eventualmente vuoto) radicato nella radice e senza buchi Le foglie di T sono i nodi che hanno entry con chiave k ma i cui figli hanno entri con chiave > k. visita in preorder di T T T

70 70 Soluzione migliore (continua) Algoritmo Print(T,i,k): Input: Heap T, indice i [1, last], chiave k Output: stampa le entry con chiave k nel sottoalbero con radice T [i] if T [i].getkey() k then stampa T [i]; if 2i last and T [2i].getKey() k then Print(T,2i,k); if 2i + 1 last and T [2i + 1].getKey() k then Print(T,2i + 1,k); Prima invocazione: i = 1 Complessità: come la visita in preorder di T Θ (m + 1)

71 Esercizio (C-9.36 [GTG14]) Siano T 1 e T 2 due alberi binari (non necessariamente completi e implementati tramite struttura linkata) i cui nodi memorizzano delle entry in modo da soddisfare la heap-order property. Descrivere un algoritmo per combinare T 1 e T 2 in un unico albero binario T i cui nodi contengano tutte le entry di T 1 e T 2, mantenendo la heap-order property. La complessità dell algoritmo deve essere O (h 1 + h 2 ), dove h 1 e h 2 rappresentano le altezze di T 1 e T 2, rispettivamente. Idea: 1 si rimuove una foglia v da T 1 ; Svolgimento 2 si crea un nuovo radice r contenente la entry e precedentemente contenuta in v, assegnandole T 1 e T 2 come figli sx e dx, rispettivamente; 3 si esegue il down-heap bubbling a partire da r. La scrittura dello pseudocodice e l analisi sono lasciati come esercizio. 71

72 Esempio domande prima parte 72 Dare la definizione di heap. Definire il level numbering indicandone la principale proprietà. Descrivere l implementazione del metodo removemin per uno heap P realizzato tramite array, e analizzarne la complessià.

73 Errata 73 Cambiamenti rispetto alla prima versione dei lucidi: Lucido 19: Modificato il punto finale Lucidi 22 e 23: invertito l ordine dei due lucidi.