Cerchiamo di rispondere alla seconda domanda 2)La soluzione trovata con lalgoritmo goloso è ottima o esistono anche soluzioni con più di quattro attività? ActivitySelector(a, s, f, n) // f 1... f n A = {a 1 }, k = 1 for m = 2 to n if s[m] f[k] A = A {a m }, k = m return A

Lalgoritmo comincia con scegliere la prima attività a 1 (quella con tempo di fine minimo) Siamo sicuri che questa scelta non possa compromettere il risultato? In altre parole: esiste sempre una soluzione ottima che contiene a 1 ?

La risposta è affermativa. Sia b 1,...,b j una qualsiasi soluzione ottima (ne esiste certamente almeno una) che supponiamo ordinata per tempo di fine b1b1 b2b2 bjbj ………………….. a1a1 b2b2 bjbj a1a1

k viene posto ad 1 ed aggiornato ad m ogni volta che si sceglie una nuova attività a m Siccome le attività sono ordinate per tempo di fine non decrescente, f[k] è il massimo tempo finale delle attività selezionate precedentemente. ActivitySelector(a, s, f, n) // f 1... f n A = {a 1 }, k = 1 for m = 2 to n if s[m] f[k] A = A {a m }, k = m return A

Con il test: Siamo sicuri che questa scelta non comprometta il risultato? In altre parole: esiste sempre una soluzione ottima che contiene a m e le attività finora scelte? lalgoritmo seleziona la prima attività a m il cui tempo di inizio s[m] è maggiore o uguale di f[k] if s[m] f[k] A = A {a m }, k = m

La risposta è ancora affermativa. Assumiamo che esista una soluzione ottima b 1,...,b i,b i+1,...,b j che estende le attività b 1,...,b i finora scelte e supponiamo b 1,...,b i e b i+1,...,b j ordinate per tempo di fine amam b1b1 bibi bjbj ….. b i+2 amam b1b1 bibi bjbj ….. b i+1 ….. b i+2 f[k]f[k]

Sappiamo quindi che durante tutta lesecuzione dellalgoritmo esiste sempre una soluzione ottima contenente le attività b 1,...,b i scelte fino a quel momento Quando lalgoritmo termina non ci sono altre attività compatibili con b 1,...,b i e quindi le attività b 1,...,b i sono una soluzione ottima

Lalgoritmo è goloso perchè ad ogni passo, tra tutte le attività compatibili con quelle già scelte, sceglie quella che termina prima. Questa scelta è localmente ottima (golosa) perché è quella che lascia più tempo a disposizione per le successive attività.

Esercizio 1. Problema dello zaino frazionario: Dati n tipi di merce M 1,…,M n in quantità rispettive q 1,…,q n e con costi unitari c 1,…,c n si vuole riempire uno zaino di capacità Q in modo che il contenuto abbia costo massimo. Mostrare che il seguente algoritmo risolve il problema: RiempiZaino(q, c, n, Q) // c 1 c 2... c n Spazio = Q for i = 1 to n if Spazio q[i] z[i] = q[i], Spazio = Spazio – z[i] else z[i] = Spazio, Spazio = 0 return z

Esercizio 2. Problema dello zaino 0-1: Sono dati n tipi di oggetti O 1,…,O n in numero illimitato. Un oggetto di tipo O i occupa un volume v i e costa c i. Si vuole riempire uno zaino di capacità Q in modo che il contenuto abbia costo massimo. Mostrare che il seguente algoritmo non risolve il problema. RiempiZaino(v, c, n, Q) // c 1 /v 1 c 2 /v 2... c n /v n Spazio = Q for i = 1 to n z[i] = Spazio/v[i] Spazio = Spazio – z[i]v[i] return z

Esercizio 3 Siano a 1,...,a n attività didattiche aventi tempi di inizio s 1,...,s n e tempi di fine f 1,...,f n e supponiamo di avere un insieme sufficiente di aule in cui svolgerle. Trovare un algoritmo per programmare tutte le attività usando il minimo numero possibile di aule.

Esercizio 4 Siano a 1,...,a n attività didattiche aventi tempi di inizio s 1,...,s n e tempi di fine f 1,...,f n e abbiamo a disposizione m aule A 1,..., A m Trovare un algoritmo goloso per programmare il massimo numero di attività nelle m aule.

Codici di Huffman I codici di Huffman vengono usati nella compressione dei dati. Essi permettono un risparmio compreso tra il 20% ed il 90%. Sulla base delle frequenze con cui ogni carattere appare nel file, lalgoritmo goloso di Huffman trova un codice ottimo ossia un modo ottimale di associare ad ogni carattere una sequenza di bit detta parola di codice.

Sia dato un file di 120 caratteri con frequenze: carattere a b c d e f frequenza Usando un codice a lunghezza fissa occorrono 3 bit per rappresentare 6 caratteri. Ad esempio carattere a b c d e f cod. fisso Per codificare il file occorrono = 360 bit.

Possiamo fare meglio con un codice a lunghezza variabile che assegni codici più corti ai caratteri più frequenti. Ad esempio con il codice carattere a b c d e f frequenza cod. var Bastano = 260 bit

Codici prefissi Un codice prefisso è un codice in cui nessuna parola codice è prefisso (parte iniziale) di unaltra Ogni codice a lunghezza fissa è ovviamente prefisso. Ma anche il codice a lunghezza variabile che abbiamo appena visto è un codice prefisso. Codifica e decodifica sono semplici con i codici prefissi.

Con il codice prefisso la codifica della stringa abc è carattere a b c d e f cod. var La decodifica è pure semplice. Siccome nessuna parola codice è prefisso di unaltra, la prima parola codice del file codificato risulta univocamente determinata.

Per la decodifica basta quindi: 1.individuare la prima parola codice del file codificato 2.tradurla nel carattere originale e aggiungere tale carattere al file decodificato 3.rimuovere la parola codice dal file codificato 4.ripetere loperazione per i caratteri successivi

Ad esempio con il codice la suddivisione in parole codice della stringa di bit è a cui corrisponde la stringa aabe carattere a b c d e f cod. var Per facilitare la suddivisione del file codificato in parole codice è comodo rappresentare il codice con un albero binario.

Esempio: il codice a lunghezza fissa carattere a b c d e f frequenza cod. fisso a:57f:5e:9d:24c:12b: ha la rappresentazione ad albero

a:57f:5e:9d:24c:12b: In realtà, come albero binario, la rappresentazione sarebbe Noi eliminiamo le foglie e chiamiamo foglie i nodi interni senza figli

Il codice a lunghezza variabile a: b:13c:12 d:24 f:5e: è rappresentato carattere a b c d e f frequenza cod. var

La lunghezza in bit del file codificato con il codice rappresentato da un albero T è: in cui la sommatoria è estesa a tutti i caratteri c dellalfabeto Σ, f c è la frequenza del carattere c e d T (c) è la profondità della foglia che rappresenta il carattere c nellalbero T Nota: assumiamo che lalfabeto Σ contenga almeno due caratteri. In caso contrario basta un numero per rappresentare il file: la sua lunghezza

La lunghezza in bit del file codificato è anche: in cui la sommatoria è estesa alle frequenze x. f di tutti i nodi interni x dellalbero T a: b:13c:12d:24 f:5e:

a:57b:13c:12 14 d:24 f:5e:9 01 Q a:57d:24f:5e:9 Q b:13c:12 carattere a b c d e f frequenza Costruzione dellalbero di Huffman: a:57 25 b:13c: d:24 f:5e:9 01 Q

a:57 25 b:13c: d:24 f:5e: Q a:57 25 b:13c: d:24 f:5e:9 01 Q

a:57 25 b:13c: d:24 f:5e: Q 63 a: b:13c:12d:24 f:5e: Q

63 a: b:13c:12d:24 f:5e: Q a: b:13c:12d:24 f:5e: Q

Implementazione dellalgoritmo goloso di Huffman Huffman(c, f, n) Q = Ø // coda con priorità for i = 1 to n Push(Q, Nodo(f i, c i )) for j = n downto 2 x = ExtractMin(Q) y = ExtractMin(Q) Push(Q, Nodo(x, y)) return ExtractMin(Q) Nodo(f, c) costruttore dei nodi foglia Nodo(x, y) costruttore dei nodi interni

Assumendo che la coda Q venga realizzata con un heap, le operazioni Insert ed ExtractMin richiedono tempo O(log n). Pertanto lalgoritmo richiede tempo O(n log n) (dove n è il numero di caratteri dellalfabeto).

Lalgoritmo è goloso perché ad ogni passo costruisce il nodo interno avente frequenza minima possibile. Ricordiamo infatti che Siamo sicuri che in questo modo otteniamo sempre un codice ottimo?

Elementi della strategia golosa Ingredienti comuni a molti problemi risolvibili con la strategia golosa: Sottostruttura ottima: Ogni soluzione ottima non elementare si ottiene da soluzioni ottime di sottoproblemi. Proprietà della scelta golosa: La scelta localmente ottima (golosa) non pregiudica la possibilità di arrivare ad una soluzione globalmente ottima.

Se T è ottimo ogni nodo interno ha due figli (altrimenti togliendo il nodo si otterrebbe un codice migliore) a: b:13c:12 d:24 f:5e: a: b:13c:12 d:24 f:5 e: Se T è ottimo esistono due foglie sorelle x ed y a profondità massima.

Proprietà (sottostruttura ottima) Sia T lalbero di un codice prefisso ottimo per lalfabeto Σ e siano a ed b i caratteri associati a due foglie sorelle x ed y di T. Se consideriamo il padre z di x ed y come foglia associata ad un nuovo carattere c con frequenza f c = z.f = f a + f b allora lalbero T'=T - {x,y} rappresenta un codice prefisso ottimo per lalfabeto Σ' = Σ - {a,b} {c}

Supponiamo, per assurdo, esista un albero S ' per Σ ' tale che B(S ' ) < B(T ' ). Aggiungendo ad S ' le foglie x ed y come figlie del nodo z (che in S ' è una foglia) otterremmo un albero S per Σ tale che B(S) < B(T) contro lipotesi che T sia ottimo.

a b T xy z c T z S a b z xy c S z

Proprietà (scelta golosa) Siano a e b due caratteri di Σ aventi frequenze f a ed f b minime Esiste un codice prefisso ottimo in cui le parole codice di a e b hanno uguale lunghezza e differiscono soltanto per lultimo bit. Se i codici di a e b differiscono soltanto per lultimo bit, nellalbero del codice le foglie a e b sono figlie dello stesso nodo, cioè sorelle.

Attenzione: Il Lemma non dice che ciò è vero per ogni codice prefisso ottimo e tanto meno che se ciò è vero il codice è ottimo!!!! Dice solo che ciò è vero per almeno un codice ottimo.

Sappiamo che in T esistono due foglie sorelle a profondità massima. Siano c e d i caratteri di tali foglie. Mostriamo che scambiando c e d con a e b il codice rimane ottimo. Possiamo supporre f c f d ed f a f b. a e b sono i due caratteri con frequenza minima in assoluto e quindi f a f c ed f b f d.

c b a d T a b c d T Sia T' ottenuto da T scambiando la foglia c con la foglia a (con ricalcolo delle frequenze dei nodi interni) f a f c ed f b f d.

Allora: Siccome T è ottimo B(T) = B(T') e quindi anche T' è ottimo. Scambiando poi le foglie d e b, si ottiene ancora un albero ottimo T'' in cui a e b sono foglie sorelle.

Teorema Lalgoritmo di Huffman produce un codice prefisso ottimo Conseguenza della sottostruttura ottima e della proprietà della scelta golosa Huffman(c, f, n) Q = Ø // coda con priorità for i = 1 to n Push(Q, Nodo(f i, c i )) for j = n downto 2 x = ExtractMin(Q) y = ExtractMin(Q) Push(Q, Nodo(x,y)) return ExtractMin(Q)

Esercizio 5 Dimostrare che ogni algoritmo di compressione che accorcia qualche sequenza di bit deve per forza allungarne qualche altra.

Dimostrazione Supponiamo per assurdo che lalgoritmo accorci qualche sequenza ma non ne allunghi nessuna. Sia x la più corta sequenza che viene accorciata dallalgoritmo e sia m la sua lunghezza. Le sequenze di lunghezza minore di m sono 2 m -1 e non vengono accorciate o allungate.

Ognuna di esse viene codificata con una sequenza diversa e quindi le loro codifiche sono anchesse 2 m -1 e sono tutte di lunghezza minore di m. Dunque ognuna delle 2 m -1 sequenze più corte di m è codifica di qualche sequenza più corta di m. Dunque la codifica di x coincide con la codifica di unaltra sequenza. ASSURDO!!!!

Suggerimento: usare 2n - 1 bit per la struttura dellalbero ed n log n bits per elencare i caratteri nellordine in cui compaiono nelle foglie (usando il codice del file non compresso) Esercizio 6. Sia Σ = {c 1,...,c n } un insieme di caratteri ed f 1,...,f n le loro frequenze Rappresentare un codice prefisso ottimo per Σ con una sequenza di 2n n log n bit

a: b:13c:12d:24 f:5e: se il nodo è interno metti uno 0 e scendi sul figlio sinistro; se è una foglia metti un 1 e risali verso sinistra finché puoi: se arrivi alla radice fermati altrimenti risali di un passo verso destra e scendi sul figlio destro Parti dalla radice e ripeti:

a bcd fe se incontri uno 0 crea il figlio sinistro e scendi su tale figlio; se incontri un 1 risali verso sinistra finché puoi: se arrivi alla radice fermati altrimenti risali di un passo verso destra, crea un figlio destro e scedi su tale figlio Crea la radice e ripeti: