Algoritmi Avanzati Prof.ssa Rossella Petreschi

Slides:



Advertisements
Presentazioni simili
Algoritmi Paralleli e Distribuiti a.a. 2008/09 Lezione del 19/05/2009 Prof. ssa ROSSELLA PETRESCHI a cura del Dott. SAVERIO CAMINITI.
Advertisements

Algoritmi Paralleli e Distribuiti a.a. 2008/09 Lezione del 07/04/2009 Prof. ssa ROSSELLA PETRESCHI a cura del Dott. SAVERIO CAMINITI.
Algoritmi Avanzati a.a.2011/2012 Prof.ssa Rossella Petreschi Simulazione di lettura e scrittura concorrente Tecnica dell’accelerated cascading Lezione.
Algoritmi Avanzati a.a.2010/2011 Prof.ssa Rossella Petreschi Complessità e Trasportabilità Lezione n°3.
Algoritmi Avanzati a.a.2014/2015 Prof.ssa Rossella Petreschi Lezione n°9.
Huffman Canonico: approfondimento. Come abbiamo visto, Huffman canonico ci permette di ottenere una decompressione più veloce e con un uso più efficiente.
Prof.ssa Rossella Petreschi Lezione del 29 /10/2014 del Corso di Algoritmica Lezione n°8.
Algoritmi Avanzati a.a.2013/2014 Prof.ssa Rossella Petreschi Somme prefisse Lezione n°2.
Algoritmi Avanzati a.a.2011/2012 Prof.ssa Rossella Petreschi L’ausilio delle occorrenze Circuiti di ordinamento Lezione n°5.
Algoritmi Avanzati a.a.2014/2015 Prof.ssa Rossella Petreschi
Algoritmi e Strutture dati a.a.2010/2011 Prof.ssa Rossella Petreschi
Algoritmi Avanzati a.a.2014/2015 Prof.ssa Rossella Petreschi
Algoritmi Avanzati a.a.2013/2014 Prof.ssa Rossella Petreschi
Algoritmi Avanzati a.a.2013/2014 Prof.ssa Rossella Petreschi
Algoritmi e Strutture dati a.a.2010/2011 Prof.ssa Rossella Petreschi
Algoritmi Avanzati a.a.2014/2015 Prof.ssa Rossella Petreschi
Algoritmi Avanzati a.a.2014/2015 Prof.ssa Rossella Petreschi
Lezione n°10 Prof.ssa Rossella Petreschi
Algoritmi Avanzati a.a.2012/2013 Prof.ssa Rossella Petreschi
Progettare algoritmi veloci usando strutture dati efficienti
Inserzione e Cancellazione
Algoritmi Avanzati a.a.2014/2015 Prof.ssa Rossella Petreschi
Algoritmi Avanzati a.a.2015/2016 Prof.ssa Rossella Petreschi
Algoritmi e Strutture dati a.a.2010/2011 Prof.ssa Rossella Petreschi
Progettare algoritmi veloci usando strutture dati efficienti
Alberi di ricerca di altezza logaritmica
Analisi di sequenze di operazioni Union-Find
Algoritmi Avanzati a.a.2014/2015 Prof.ssa Rossella Petreschi
Algoritmi Avanzati a.a.2010/2011 Prof.ssa Rossella Petreschi
Lezione n°9 Prof.ssa Rossella Petreschi
Algoritmi Avanzati a.a.2014/2015 Prof.ssa Rossella Petreschi
Algoritmi Avanzati a.a.2013/2014 Prof.ssa Rossella Petreschi
Algoritmi Avanzati Prof.ssa Rossella Petreschi
Algoritmi Avanzati a.a.2011/2012 Prof.ssa Rossella Petreschi
Rappresentazione di alberi
Correzione 1° Esonero Lezione n°13
Algoritmi Avanzati a.a.2014/2015 Prof.ssa Rossella Petreschi
B-alberi e alberi autoaggiustanti
Algoritmi Avanzati a.a.2011/2012 Prof.ssa Rossella Petreschi
Algoritmi Avanzati a.a.2015/2016 Prof.ssa Rossella Petreschi
Complessità ammortizzata degli algoritmi Union Find
Algoritmi Avanzati a.a.2013/2014 Prof.ssa Rossella Petreschi
La gestione degli insiemi disgiunti
Algoritmi Avanzati a.a.2013/2014 Prof.ssa Rossella Petreschi
Algoritmi Avanzati Prof.ssa Rossella Petreschi
Algoritmi Avanzati a.a.2011/2012 Prof.ssa Rossella Petreschi
Sulla complessità Lezione n°2
Algoritmi Avanzati Prof.ssa Rossella Petreschi
Algoritmi Avanzati Prof.ssa Rossella Petreschi
Algoritmi Avanzati a.a.2010/2011 Prof.ssa Rossella Petreschi
Algoritmi Avanzati a.a.2014/2015 Prof.ssa Rossella Petreschi
Lezione n°4 Prof.ssa Rossella Petreschi
Algoritmi Avanzati a.a.2010/2011 Prof.ssa Rossella Petreschi
Rappresentazione di alberi
Lezione n°6 Prof.ssa Rossella Petreschi
Algoritmi e Strutture Dati
Algoritmi e Strutture Dati
Algoritmi Avanzati a.a.2011/2012 Prof.ssa Rossella Petreschi
Progettare algoritmi veloci usando strutture dati efficienti
Algoritmi Avanzati Prof.ssa Rossella Petreschi
Algoritmi e Strutture dati a.a.2010/2011 Prof.ssa Rossella Petreschi
Backtracking Lezione n°17 Prof.ssa Rossella Petreschi
Esercizio Dato un albero binario, definiamo altezza minimale di un nodo v la minima distanza di v da una delle foglie del suo sottoalbero, definiamo invece.
Algoritmi Avanzati a.a.2010/2011 Prof.ssa Rossella Petreschi
Algoritmi e Strutture dati a.a.2010/2011 Prof.ssa Rossella Petreschi
MergeSort Usa la tecnica del divide et impera:
Lezione n°7 Splay-Trees e Heaps Prof.ssa Rossella Petreschi
Algoritmi e Strutture dati a.a.2010/2011 Prof.ssa Rossella Petreschi
Unione per ranghi compressi
HeapSort Stesso approccio incrementale del selectionSort Tipo di dato
Transcript della presentazione:

Algoritmi Avanzati Prof.ssa Rossella Petreschi FONDERE PER ORDINARE Lezione n°12 Algoritmi Avanzati Prof.ssa Rossella Petreschi 1

Il concetto di rango Dati X = (x1, x2, …, xt), Y = (y1, y2, …, ys) e z, con z, xi e yj nello stesso insieme U, definiamo: 1. rango(z:X) = numero di elementi in X  z Es: X = (-3,8,-2,5), z = 1, rango(z:X) = 2 2. rango(Y:X) = (r1, r2, … rs) con ri = rango(yi:X) Es: X = (15,-3,12,1,-5), Y = (3,-13,-2), rango(Y:X) = (3,0,2) Si noti inoltre che vale la relazione*: rango(x:AB) = rango(x:A) + rango(x:B) *Nota: per semplicità assumiamo che i valori siano tutti distinti.

Fondere tramite rango Il problema di fondere due vettori ordinati A e B in un unico vettore C si può risolvere calcolando il rango degli elementi di A rispetto a B e di quelli di B rispetto ad A: rango(x:AB) è esattamente la posizione in cui l’elemento x si trova nel vettore C. L’algoritmo di Ricerca Binaria può essere utilizzato per calcolare il rango di un elemento in un vettore, ed in particolare il rango di ogni elemento di A in B e viceversa. Con tali informazioni possiamo calcolare C. Esempio: A=(-2, -1, 8) B=(3,6) AB=(-2, -1, 8, 3, 6) rango(A:B)=(0, 0, 2) rango(B:A)=(2,2) rango=(1, 2, 5, 3, 4) C=(-2, -1, 3, 6, 8)

Inserire una sequenza “breve” in un vettore ordinato Siano X=(x1, x2, …, xn) un vettore ordinato e Y=(y1, …, ym) una sequenza di valori qualunque tale che m=O(ns) con 0≤s≤1. Utilizziamo un numero di processori pari ad N=n/m = (n1-s). È possibile inserire ciascun valore yi nella sequenza X determinando rango (yi:X) in tempo O(m log2(n+2) / log2(N+1)) Quando m << n (ovvero se s  0) si ha N=O(n) e tempo O(1). Quando m=O(n) (s  1) si ha N=O(1) e tempo O(n log n).

Algoritmo di fusione tramite rango Input: A=(a1, a2, …, an), B=(b1, b2, …, bm), ordinati in modo crescente (m≤n). Output: C=(c1, c2, …, cn+m), ordinato in modo crescente. Idea: si partiziona il vettore B in (m / log m) blocchi consecutivi di log(m) elementi ciascuno, B0, B1, …, e si crea il vettore Y= (y0, y1, …, ) costituito dall’insieme degli elementi massimi dei blocchi, yi= B(i(logm-1)). Si calcola rango(Y:A) e si ottiene (r0, r1, …, rm/logm), con r0= 0, ri= rango(yi:A), 1≤i≤logm-1, rm/logm=n e si divide A in blocchi consecutivi: A0=(a1, …, ar1), A1=(ar1+1, …, ar2), …, Ar(m/llogm)-1= (ar(m/llogm)-1, …, ar(m/llogm)). Poiché A0 e B0 contengono elementi minori di tutti gli altri elementi di A e B, fondendo A0 e B0 tramite rango si ottiene la sequenza ordinata dei primi elementi di C. Iterando il ragionamento su tutte le coppie Ai e Bi si ottiene l’intero vettore C ordinato.

Esempio di applicazione dell’algoritmo di fusione B = [ 3, 9, 16, 17 ] rango(9:A) = 3 rango(17:A) = 6 r = [ 0, 3, 6, 8 ] B0 = [ 3, 9 ] B1 = [ 16, 17 ] A0 = [ 4, 6, 7 ] A1 = [ 10, 12, 15] A2 = [ 18, 20 ] log m log m

Dettaglio del partizionamento begin P0: r [ 0 ] = 0 r [ m / log m ] = n for i = 1 to m/log m -1 pardo Pi: r [ i ] = rango(B[ i (log m -1)] : A) for i = 0 to m/log m -1 pardo Pi: Bi = (B[ i log m ], …, B[(i+1)(log m -1)]) Ai = (A[ r [ i ] ], …, A[ r [i+1] -1]) end

Complessità dell’algoritmo di fusione Per completare la fusione di A e B (cioè per calcolare la posizione di ciascun valore nel vettore finale) si dovranno fondere tutte le coppie di sottovettori (Ai, Bi). Utilizzando l’inserimento di una seq. breve in un vettore ordinato ciò si può fare in O(log m) tempo con |Ai| processori. Quindi con n processori tutte le coppie possono essere fuse contemporaneamente in tempo logaritmico. Gli elementi di Ai e Bi vengono posizionati nel vettore risultante C in tempo parallelo costante tenuto conto che: ogni Ai contribuisce con (ri+1 – ri); ogni Bj contribuisce con log m elementi. Il tempo totale richiesto è pertanto O(log n) con n processori su PRAM CREW. Esistono anche algoritmi che riducono la complessità temporale a O(log log n) portando quindi il costo totale a O(n log log n).

Ordinamento per fusione La versione parallela del ben noto algoritmo mergesort si può descrivere tramite un albero binario completo di altezza logn che contiene nelle foglie gli n elementi da ordinare. Al passo k-esimo lavorano in parallelo tutti i processori assegnati ai nodi del livello* logn-k ed ogni processore esegue la fusione dei valori presenti nei suoi nodi figli. Ad ogni passo il tempo parallelo richiesto è determinato dall’algoritmo di fusione utilizzato e il numero di passi è pari all’altezza dell’albero. Per quanto detto in precedenza, il miglior costo che si può avere per questo algoritmo è pertanto pari a O(n logn loglog n), non ottimo, anche se molto efficiente. * si suppone che la radice sia a livello 0 e le foglie a livello logn

Verso un ordinamento ottimo Nel 1988 R. Cole presentò sul SIAM Journal Computing la prima versione del pipelined merge sort (poi conosciuto come algoritmo di Cole) che riduceva il calcolo delle fusioni ad ogni livello. Da allora varianti e raffinamenti dell’algoritmo si sono susseguiti in letteratura fino a raggiungere un costo ottimo su PRAM EREW. L’idea di Cole per eliminare il tempo dovuto all’operazione di fusione è nata dal constatare che le operazioni di fusione dei sottovettori non è necessario compierle in un sol passo, dato che per arrivare alla soluzione bisogna percorrere tutto l’albero, dalle foglie alla radice. Il calcolo delle fusioni ad ogni singolo livello si può pertanto realizzare in un numero costante di passi fondendo, ad ogni passo, opportuni valori scelti a campione. Questi valori campione, in numero costante, richiedono tempo parallelo O(1) per essere calcolati, confrontati ed inseriti provvisoriamente nel vettore soluzione parziale. Il calcolo di nuovi campioni ad ogni livello garantisce la realizzazione alla radice del vettore ordinato (ottenuto per ripetute fusioni parziali) e permette di ottenere un tempo parallelo logaritmico per l’intero algoritmo di ordinamento.