Lezione n°10 Prof.ssa Rossella Petreschi

Slides:



Advertisements
Presentazioni simili
Algoritmi Avanzati a.a.2013/2014 Prof.ssa Rossella Petreschi Albero ricoprente di costo minimo Lezione n°12.
Advertisements

Prof.ssa Rossella Petreschi Lezione del 5/12/2012 del Corso di Algoritmi e Strutture Dati Riferimenti: Capitolo 11 del testo Anany Levitin “The design.
Teorema di Ramsey Lower bound cubico Disuguaglianza di Fisher Lezione 6 dal libro di Babai & Frankl: Linear Algebra Methods in Combinatorics with applications.
Prof.ssa Rossella Petreschi Lezione del 1 /12/ 2011 del Corso di Algoritmi e Strutture Dati Riferimenti: capitolo 17 del testo M.H.Alsuwaiyel “Algorithms:
Prof.ssa Rossella Petreschi Lezione del 3/12/2013 del Corso di Algoritmica GRAFI e PLANARITA’ Lezione n°15.
Prof.ssa Rossella Petreschi Lezione del 29 /10/2014 del Corso di Algoritmica Lezione n°8.
Algoritmi e Strutture dati a.a.2010/2011 Prof.ssa Rossella Petreschi
Algoritmi Avanzati a.a.2014/2015 Prof.ssa Rossella Petreschi
Progettare algoritmi veloci usando strutture dati efficienti
Inserzione e Cancellazione
Branch and Bound Lezione n°19 Prof.ssa Rossella Petreschi
Branch and Bound Lezione n°14 Prof.ssa Rossella Petreschi
Progettare algoritmi veloci usando strutture dati efficienti
Reti, flussi e tagli Lezione n°11
Analisi di sequenze di operazioni Union-Find
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
La funzione Path e le forme a cespuglio
Algoritmi Avanzati Prof.ssa Rossella Petreschi
Lezione n°17 Prof.ssa Rossella Petreschi
Lezione n°15 Prof.ssa Rossella Petreschi
Rappresentazione di alberi
Rappresentazione di alberi binari
B-alberi e alberi autoaggiustanti
Algoritmi Avanzati a.a.2011/2012 Prof.ssa Rossella Petreschi
Algoritmi Avanzati a.a.2014/2015 Prof.ssa Rossella Petreschi
Complessità ammortizzata degli algoritmi Union Find
Lezione n°14 Reti di flusso Prof.ssa Rossella Petreschi
Macchine sequenziali Capitolo 4.
Algoritmi Avanzati Prof.ssa Rossella Petreschi
Algoritmi Avanzati a.a.2011/2012 Prof.ssa Rossella Petreschi
Lezione n°16 Abbinamento Prof.ssa Rossella Petreschi
Algoritmi Avanzati Prof.ssa Rossella Petreschi
Algoritmi Avanzati Prof.ssa Rossella Petreschi
Algoritmi Avanzati a.a.2014/2015 Prof.ssa Rossella Petreschi
Usi (meno scontati) della visita DFS
Algoritmi Avanzati a.a.2010/2011 Prof.ssa Rossella Petreschi
Paths, tree and flowers Lezione n°14
K4 è planare? E K3,3 e K5 sono planari? Sì!
per rappresentare grafi
Lezione n°11 Prof.ssa Rossella Petreschi
Lezione n°12 Prof.ssa Rossella Petreschi
ABBINAMENTO Lezione n°13
Algoritmi e Strutture dati a.a.2010/2011 Prof.ssa Rossella Petreschi
Algoritmi e Strutture Dati
Rappresentazione di alberi
Algoritmi per il flusso nelle reti
Lezione n°6 Prof.ssa Rossella Petreschi
Branch and Bound Lezione n°18 Prof.ssa Rossella Petreschi
Analisi ammortizzata Lezione n°3
Schema generale, visita in ampiezza e profondità.
Backtracking Lezione n°13 Prof.ssa Rossella Petreschi
Usi (meno scontati) della visita DFS
Lezione n°14 Prof.ssa Rossella Petreschi
Progettare algoritmi veloci usando strutture dati efficienti
Algoritmi Avanzati Prof.ssa Rossella Petreschi
Automi e stringhe Lezione n°24 Prof.ssa Rossella Petreschi
Algoritmi e Strutture dati a.a.2010/2011 Prof.ssa Rossella Petreschi
Algoritmi e Strutture dati a.a.2010/2011 Prof.ssa Rossella Petreschi
Backtracking Lezione n°17 Prof.ssa Rossella Petreschi
Alberi di ricerca Lezione n°4
Alberi e parentesi Lezione n°9
Grafi e problem solving
Lezione n°7 Splay-Trees e Heaps Prof.ssa Rossella Petreschi
Algoritmi e Strutture dati a.a.2010/2011 Prof.ssa Rossella Petreschi
Il problema del flusso nelle reti
Algoritmi e Strutture dati a.a.2010/2011 Prof.ssa Rossella Petreschi
Unione per ranghi compressi
Algoritmi.
Transcript della presentazione:

Lezione n°10 Prof.ssa Rossella Petreschi Lezione del 07/11/2014 del Corso di Algoritmica

Rappresentazione esplicita di Rank Nella rappresentazione esplicita del rank si hanno m (=2n+1) interi di logm bit ciascuno , da cui: Spazio: mlogm bit; Tempo: O(1) b(i) 1 1 1 0 1 0 0 1 1 0 0 0 0 0 0 0 ……… i 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 ……… ---------------------------------------------------------------------------------------- Rank 1 2 3 3 4 4 4 5 6 6 6 6 6 6 6 6 ………. Per ridurre lo spazio, si partiziona il vettore b in segmenti di dimensione k=logm/2 . Per ogni segmento si calcola un solo valore di rango, quindi avremo m/k= m/(logm/2) interi di logm bits ciascuno, da cui: Spazio: 2m bit; 2

Implementazione di Rank j 1 2 3 4 5 b(i) 1 1 1 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0…… i 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20…… ---------------------------------------------------------------------------------------- Rank 1 2 3 3 4 4 4 5 6 6 6 6 6 6 6 6 6 6 6 6 6… Tempo O(1) per conoscere il Rank (=Rank’) degli elementi campionati e per gli altri??? per gli elementi non campionati….. Rank(b,6) = Rank’[1] + #1nei primi 3 elementi di b[4,7] = 3 +1 =4 3

Numero degli 1 in un fissato intervallo di b C(h,2h): riporta il numero di 1 contenuti nelle prime h posizioni di tutti i possibili segmenti elementari  C(h,2h)= k2k = ((logm) /2)2(logm)/2 elementi di O(logk) bit ciascuno h=0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 h=1 0 0 0 0 1 1 1 1 1 1 1 1 2 2 2 2 h=2 0 0 1 1 1 1 2 2 1 1 2 2 2 2 3 3 h=3 0 1 1 2 1 2 2 3 1 2 2 3 2 3 3 4 Rank(b,6) = Rank’[1] + #1nei primi 3 elementi di b[4,7] = Rank’[1] + C[2,9] = 3 +1 =4 Dove Rank’[1] è il valore del Rank campionato più vicino a sinistra all’indice di cui si vuole calcolare il Rank; 9 è il numero decimale corrispondente al numero binario scritto in b nello intervallo [4,7] e la riga 2 indica che si debbono contare gli 1 nei primi 3 elementi in [4,7]. In generale Rank(b,i) = Rank’ [q] + C[r,s] dove q = ⎣i/k⎦ ed r = i-qk sono calcolabili in tempo O(1) e s??? 4

Calcolo di s in O(1) Rank’ 3 5 6 6 6 m/k = 2m/logm j 1 2 3 4 5 b’(j) 14 9 8 0 0 0≤ b’(j) < m1/2 b(i) 1 1 1 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0…… k=1/2 logm i 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20…… ---------------------------------------------------------------------------------------- Rank 1 2 3 3 4 4 4 5 6 6 6 6 6 6 6 6 6 6 6 6 6… Da cui Rank(b,i) = Rank’ [q] + C[r,b’[q+1]] Rank(b,6) = Rank’[1] + C[r,b’[q+1]] = Rank’[1] + C[2,b’[2]] = 3 +1 =4 5

2m è ancora troppo Dato un array di 256 bits i 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20…… 32 interi di 8 bit ciascuno: b(i) 1 1 1 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0… mlogm Rank 1 2 3 3 4 4 4 5 6 6 6 6 6 6 6 6 6 6 6 6 6 i 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20…… 8 interi di 8 bit ciascuno: b(i) 1 1 1 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0… 2m (k=logm/2) Rank’ 3 5 6 6 6 i 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20…… 4 interi di 8 bit ciascuno: b(i) 1 1 1 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0… O(m/logm)(k=(log2m)/8) Rank” 5 6 6

..di conseguenza L’operazione di Rank(b,i) si esegue in tempo costante con l’aggiunta di o(m) bit ai bit richiesti dal vettore b Infatti: Lo spazio occupato da Rank” è O(m/logm)bit Lo spazio occupato da Rank’ è O(mloglogm/logm)bit Si partiziona b in blocchi da k = (log2m)/8 bit e per ciascuno di questi blocchi si costruisce l’array Rank’ relativo (così è garantito che ogni elemento di Rank’ richiede O(loglogm) bit dato che le somme parziali all’interno di ogni singolo blocco Rank’ possono aver valore al più k) Lo spazio occupato da C è O( m1/2 logm) O(log(logm/2)) bit Quindi aggiungiamo o(m) ai bit richiesti da b’ aggiungiamo Rank”(8i/log2m) al calcolo del Rank(b,i) Esempio: Rank(b,12) = Rank”(1) + Rank’(3) + C[0,b’[4]] = Rank”(1) + Rank’(3) + C[0,0] = 5 + 1 + 0 = 6 7

L’abbinamento Abbinamento (accoppiamento) in un grafo connesso non orientato (e privo di loop) è un qualsiasi insieme M di archi a due a due non incidenti. La cardinalità di M è la cardinalità dell’abbinamento. Un nodo si dice saturo (esposto) se è (non è) estremo di un qualche arco in M. M è un abbinamento massimale se non è sottoinsieme proprio di alcun abbinamento in G. M è un abbinamento massimo se non esiste un altro abbinamento in G con cardinalità maggiore di quella di M. M è un abbinamento perfetto se non lascia alcun nodo esposto. 8

Proprietà dell’abbinamento Grafi qualunque G ( V, E ), V = n Ogni abbinamento massimo è massimale Ogni abbinamento perfetto è massimo Un abbinamento massimo non è detto sia perfetto In un grafo possono esistere distinti abbinamenti perfetti Un abbinamento può avere al più n/2 archi Un abbinamento è perfetto se e solo se ha n/2 archi Se un grafo ha un abbinamento perfetto, allora ha un numero pari di nodi 9

Sui grafi bipartiti G(XUY,E) VALE La cardinalità di un abbinamento massimo è al più il minimo fra la cardinalità di X e quella di Y G non può avere un abbinamento perfetto se |X| ≠ |Y| Teorema del matrimonio (Jacobi 1890, Frobenius 1917, Hall 1935) G(XUY, E) ha un abbinamento perfetto sse X = Y S ≤ N(S) per ogni S in X Teorema di Konig-Egervary (Konig 1930, Egervary1931) In ogni grafo bipartito la cardinalità massima di un abbinamento è uguale alla cardinalità minima di un ricoprimento (insieme di nodi che copre tutti gli archi del grafo) 10

Applicazioni Grafo bipartito In una azienda n nuovi assunti da assegnare ad n differenti lavori Scegliere fra i componenti di una squadra di nuoto il team giusto da portare ad una gara in modo da poter partecipare a tutte le discipline Grafo qualunque Scegliere opportunamente coppie di persone a cui far condividere una stanza d’albergo. Una compagnia aerea multiculturale deve scegliere i due piloti dello stesso aereo in modo che abbiano lo stesso tipo di addestramento e parlino una lingua comune e poi abbinamenti di strutture chimiche, scheduling parallelo di differenti lavori su diverse macchine, assegnamento di turni in una fabbrica………. 11