Algoritmi Avanzati a.a.2014/2015 Prof.ssa Rossella Petreschi

Presentazione sul tema: "Algoritmi Avanzati a.a.2014/2015 Prof.ssa Rossella Petreschi"— Transcript della presentazione:

1 Algoritmi Avanzati a.a.2014/2015 Prof.ssa Rossella Petreschi
Lezione n°5 Algoritmi Avanzati a.a.2014/2015 Prof.ssa Rossella Petreschi 1

2 Circuiti di ordinamento
Utilizziamo il comparatore, ossia un circuito di confronto con due ingressi e due uscite il cui valore è la coppia di valori in input ordinati in modo ascendente. I circuiti formati da comparatori, se opportunamente combinati, costituiscono un'architettura in grado di ordinare n valori di input. x y min(x,y) max(x,y) 9 5 2 7 2

3 Insertion Sort Due architetture per implementare l'insertion sort (tra 8 valori in input): Questa macchina utilizza una versione seriale dell'algoritmo di complessità O(n2) (indicata dalla profondità del circuito, ossia il numero di porte che vengono attraversate in tempi differenti). È possibile ottenere una complessità O(n) ottimizzando lo scheduling dei comparatori e parallelizzando l'algoritmo. 3

4 Sulla monotonicità Se un circuito di ordinamento trasforma la sequenza di input a = (a1, a2, …, an) nella sequenza di output b = (b1, b2, …, bn), allora per ogni funzione monotona crescente f, il circuito trasforma la sequenza di input f(a) = (f(a1), f(a2), …, f(an)) nella sequenza di output f(b)=(f(b1), f(b2), …, f(bn)). Tale proprietà è facilmente verificata da un singolo comparatore e per induzione la si può provare per un intero circuito di ordinamento. x y min(x,y) max(x,y) f(x) f(y) min(f(x), f(y))) = f(min(x,y)) max(f(x), f(y))) = f(max(x,y)) 4

5 Principio 0/1 Teorema (principio 0/1): se un circuito combinatorio di ordinamento lavora correttamente per qualunque input costruito sull'alfabeto {0,1} allora lavora correttamente per qualunque input costruito su di un qualsiasi alfabeto finito A. Dim: supponiamo per assurdo che il circuito ordini tutte le sequenze costruite sull'alfabeto {0,1} correttamente, ma che esista una sequenza di input di numeri arbitrari a = (a1, a2, …, an) contenente elementi ai e aj tali che ai < aj mentre il circuito pone aj prima di ai nella sequenza di output. Definiamo una funzione f monotona crescente come: f(x) = 0 se x <= ai f(x) = 1 se x > ai dal lemma precedente segue che il circuito sistema f(aj) prima di f(ai) nella sequenza di output quando f(a) è l'input. Ma poiché f(aj) = 1 mentre f(ai) = 0, neghiamo l'ipotesi giungendo ad un assurdo. 5

6 Sequenze bitoniche Una Sequenza Bitonica è una sequenza che può essere divisa in due sottosequenze monotone, una crescente e l'altra decrescente o viceversa. Sono bitoniche le due sequenze: m(S) = (min{s1,sn+1}, min{s2,sn+2}, …, min{sn,s2n}) M(S) = (max{s1,sn+1}, max{s2,sn+2}, …, max{sn,s2n}) ottenute dalla sequenza bitonica S = s1, s2, …, s2n Sfruttando la definizione di m(S) ed M(S) e le relative proprietà si può ottenere una definizione ricorsiva per le sequenze bitoniche che ci permette di realizzare un primo algoritmo di ordinamento che opera ricorsivamente secondo lo schema: S = S1 = m(S) = S2 = M(S) = S3 = m(S1) = S4 = M(S1) = S5 = m(S2) = S6 = M(S2) = 8 9 Complessità O(log(n)). 6

7 Sequenze pulite Una sequenza binaria si dice pulita se è composta interamente da 0 o da 1. Se S è bitonica almeno una delle due sottosequenze bitoniche m(S) e M(S) è pulita (diretta conseguenza del fatto che la cardinalità di {0,1} è due). In figura è presentato un circuito di ordinamento, di profondità logaritmica, per sequenze 0/1 bitoniche (ad ogni passo rendiamo pulita metà della sequenza). 1 7

8 Circuito di fusione Il circuito di fusione fonde due sequenze ordinate costruite sullo stesso alfabeto sfruttando il fatto che, date due sequenze ordinate entrambe crescenti (o decrescenti) x e y, la sequenza che si ottiene concatenando x con z=“y rovesciata” è bitonica (l’inversione della stringa y si realizza semplicemente variando le connessioni). La profondità del circuito è logaritmica e il numero di comparatori ad ogni passo è n/2. 1 8

9 Circuito di ordinamento
In figura è riportato un circuito di ordinamento che realizza l’ordinamento connettendo iterativamente diversi circuiti di fusione (la base di questa costruzione sta nel fatto che ogni sequenza di due elementi è bitonica). Poiché concateniamo un numero logaritmico di circuiti di fusione, otteniamo una profondità del circuito O(log2 n). 1 9

10 Applicando il teorema di Brent
Il circuito di ordinamento, O, è un circuito combinatorico di profondità d = O(log2 n), di dimensione pari al numero di comparatori c = O(nlog2n), fan in e fan out limitati. Per il Teorema di Brent, l’algoritmo di ordinamento che lavora su O può essere simulato da una algoritmo che lavora su una PRAM EREW con p processori in tempo O(c / p + d), ovvero O((n log2 n) / p + log2 n). Quando p = O(n) si ha che la complessità temporale dell'ordinamento su una PRAM EREW è O(log2 n) e il costo O(n log2 n). 10

11 Trasportabilità fra P-RAM con diverso numero di processori
Teorema (p' < p): ogni algoritmo A che lavora in tempo parallelo O(t) su una PRAM con p processori può essere simulato da un algoritmo A' che lavora su una PRAM con p' processori (p' < p) in tempo O(t p / p'). Dimostrazione: durante ognuno dei t passi dell’esecuzione di A, i p processori lavorano parallelamente in tempo O(1). Durante ogni passo della esecuzione di A', ciascuno dei p'<p processori eseguirà un blocco seriale di p/p' operazioni in tempo O(p/p'). Pertanto il tempo parallelo relativo alla esecuzione di A' sarà O(tp/p'). Il costo dei due algoritmi A e A' rimane pari a O(tp). 11

12 Numero di processori limitato (1)
Vogliamo sommare n numeri, con la tecnica della prima metà, avendo a disposizione un numero fissato a priori di p processori (p < n). Ricordiamo come si lavora con n processori Begin for i = 1 to log n do for j = 0 to n/2i -1 pardo Pj: A[ j ] = A[ j ] + A[ j+n/2i ] return A[ 0 ] end P1 P2 P3 P4 4 2 7 4 1 6 3 8 5 8 10 12 15 20 35 12

13 Numero di processori limitato (2)
p = 2 P1 P2 Vediamo cosa cambia con p <n processori Begin for i = 1 to log n do for s = 0 to (n/2i) / p -1 do for j = 0 to min(n/2i, p) -1 pardo if (j+s*p < n/2i) then Pj: A[ j+s*p ] = A[ j+s*p ] + A[ j+s*p +n/2i ] return A[ 0 ] end 4 2 7 4 1 6 3 8 s=0 i=1 5 8 7 4 1 6 3 8 s=1 i=2 5 8 10 12 s=0 i=3 15 20 s=0 35 13