Strutture Di Dati e Algoritmi

o a?

CD

œ

o

Liste ad auto-organizzazione

L'auto-organizzazione delle liste è utile quando, per svariati motivi, la lista non è necessariamente ordinata in base alle chiavi di ricerca (contrariamente al caso delle liste randomizzate del Paragrafo 3.3). Per semplificare la discussione, consideriamo il solo caso della ricerca di una chiave k in una lista e adottiamo uno schema di scansione sequenziale, illustrato nel Codice 3.1: percorriamo la lista a partire dall'inizio verificando iterativamente se l'elemento attuale è uguale alla chiave cercata. Estendiamo tale schema per eseguire eventuali operazioni di auto-organizzazione al termine della scansione sequenziale (le operazioni di inserimento e cancellazione possono essere ottenute semplicemente, secondo quanto discusso nel Paragrafo 3.1).

MoveToFrontC a , k ) : p = a; IF (p == n u l l I I p . d a t o == k) RETURN p; WHILE ( ( p . s u c c != n u l i ) && ( p . s u c c . d a t o != k ) ) p = p.succ; IF ( p . s u c c == n u l l ) RETURN n u l i ; tmp = a; a = p.succ; p.succ = p.succ.succ; a . s u c c = tmp; r e t u r n a; Codice 3.5

Ricerca di una chiave k in una lista ad auto-organizzazione.

Tale organizzazione sequenziale può trarre beneficio dal principio di località temporale, per il quale, se accediamo a un elemento in un dato istante, è molto probabile che accederemo a questo stesso elemento in istanti immediatamente (o quasi) successivi. Seguendo tale principio, sembra naturale che possiamo riorganizzare proficuamente gli elementi della lista dopo aver eseguito la loro scansione. Per questo motivo, una lista così gestita viene riferita come struttura di dati ad auto-organizzazione (self-organizing o self-adjusting). Tra le varie strategie di auto-organizzazione, la più diffusa ed efficace viene detta move-to-front ( M T F ) , che consideriamo in questo paragrafo: essa consiste nello spostare l'elemento acceduto dalla sua posizione attuale alla cima della lista, senza cambiare l'ordine relativo dei rimanenti elementi, come mostrato nel Codice 3.5. Osserviamo che MTF effettua ogni ricerca senza conoscere le ricerche che dovrà effettuare in seguito: un algoritmo operante in tali condizioni, che deve quindi servire un insieme di richieste man mano che esse pervengono, viene detto in linea {online). Un esempio quotidiano di lista ad auto-organizzazione che utilizza la strategia MTF è costituito dall'elenco delle chiamate effettuate da un telefono cellulare: in effetti, è probabile che un numero di telefono appena chiamato, venga usato nuovamente nel prossimo futuro. Un altro esempio, più informatico, è proprio dei sistemi operativi, dove la strategia MTF viene comunemente denominata least recently used (LRU). In questo caso, gli elementi della lista corrispondono alle pagine di memoria, di cui solo le prime r possono essere tenute in una memoria ad accesso veloce. Quando una pagina è richiesta, quest'ultima viene aggiunta alle prime r, mentre quella a cui si è fatto accesso meno recentemente viene rimossa. Quest'operazione equivale a porre la nuova pagina in cima alla lista, per cui quella originariamente in posizione r (acceduta meno recentemente) va in posizione successiva, r + 1, uscendo di fatto dall'insieme delle pagine mantenute nella memoria veloce.

Per valutare le prestazioni della strategia MTF, il termine di paragone utilizzato sarà un algoritmo fuori linea (offline), denominato OPT, che ipotizziamo essere a conoscenza di tutte le richieste che perverranno. Le prestazioni dei due algoritmi verranno confrontate rispetto al loro costo, definito come la somma dei costi delle singole operazioni, in accordo a quanto discusso sopra: in particolare, contiamo il numero di elementi scanditi a partire dall'inizio della lista, per cui accedere all'elemento in posizione i ha costo i in quanto dobbiamo scandire gli i elementi che lo precedono. Lo spostamento in cima alla lista, operato da MTF, non viene conteggiato in quanto richiede un costo costante. Tale paradigma è ben esemplificato dalla gestione delle chiamate in uscita di un telefono cellulare: l'ultimo numero chiamato è già disponibile in cima alla lista per la prossima chiamata e il costo indica il numero di clic sulla tastierina per accedere a ulteriori numeri chiamati precedentemente (occorrono un numero di clic pari a i per scandire gli elementi che precedono l'elemento in posizione i nell'ordine inverso di chiamata). E di fondamentale importanza stabilire le regole di azione di OPT, perché questo può dare luogo a risultati completamente differenti. Nel nostro caso, OPT parte dalla stessa lista iniziale di MTF. Esaminate tutte le richieste in anticipo, OPT permuta gli elementi della lista solo una volta all'inizio, prima di servire le richieste. A questo punto, quando arriva una richiesta per l'elemento k in posizione i, restituisce l'elemento scandendo i primi i elementi della lista, senza però muovere k dalla sua posizione. Notiamo che OPT permuta gli elementi in un ordine (per noi imprevedibile) che rende minimo il suo costo futuro. Inoltre, ai fini dell'analisi, presumiamo che le liste non cambino di lunghezza durante l'elaborazione delle richieste. A titolo esemplificativo, è utile riportare i costi in termini concreti del numero di clic effettuati sui cellulari. Immaginiamo di essere in possesso, oltre al cellulare di marca MTF, di un futuristico cellulare OPT che conosce in anticipo le n chiamate che saranno effettuate nell'arco di un anno su di esso (l'organizzazione della lista delle chiamate in uscita è mediante le omonime politiche di gestione). Potendo usare entrambi i cellulari con gli stessi m numeri in essi memorizzati, effettuiamo alcune chiamate su tali numeri per un anno: quando effettuiamo una chiamata su di un cellulare, la ripetiamo anche sull'altro (essendo futuristico, OPT si aspetta già la chiamata che intendiamo effettuare). Per la chiamata j, dove j = 0 , l , . . . , n — 1 , contiamo il numero di clic che siamo costretti a fare per accedere al numero di interesse in MTF e, analogamente, annotiamo il numero di clic per OPT (ricordiamo che MTF pone il numero chiamato in cima alla sua lista mentre OPT non cambia più l'ordine inizialmente adottato in base alle chiamate future). Allo scadere dell'anno, siamo interessati a stabilire il costo, ovvero il numero totale di clic effettuati su ciascuno dei due cellulari. Mostriamo che, sotto opportune condizioni, il costo di MTF non supera il doppio del costo di OPT. In un certo senso, MTF offre una forma limitata di chiaroveggenza delle richieste rispetto a OPT, motivando il suo impiego in vari contesti con successo. In

Lista MTF Lista PRM Figura 3.9

== ==

e

22 ei

4 e0

26

eo

Ci e

4

23 25

27 26

25 27

Un'istantanea delle liste manipolate da MTF e PRM.

realtà quella adottata da OPT è una delle possibili permutazioni degli elementi della lista: mostriamo quindi una proprietà più generale. Presa una qualunque permutazione della lista iniziale, definiamo PRM come l'algoritmo che opera sulla lista permutata in analogia a quanto descritto per OPT (ovvero un elemento non viene cambiato di posizione dopo ogni accesso). I costi di PRM sono definiti analogamente a quelli di OPT per cui, quando la permutazione è quella fissata da OPT, i comportamenti di PRM e OPT coincidono. Mostrando in generale che il costo di MTF non supera il doppio del costo di PRM, otteniamo la dimostrazione anche per il caso specifico di OPT. Formalmente, consideriamo una sequenza arbitraria di n operazioni di ricerca su una lista di m elementi, dove le operazioni sono enumerate da 0 a n — 1 in base al loro ordine di esecuzione. Per 0 ^ j ^ n - 1, l'operazione j accede a un elemento k nelle lista come nel Codice 3.5: sia Cj la posizione di k nella lista di MTF e cj la posizione di k nella lista di PRM. Poiché vengono scanditi Cj elementi prima di k nella lista di MTF, e cj elementi prima di k nella lista di PRM, definiamo il costo delle n operazioni, rispettivamente, n—1

n-1 C

costo(MTF) =

Ì

e

c

costo(PRM) =

j=0

j

(3-3)

j=0

Vogliamo mostrare che costo(MTF) ^ 2 x costo(PRM) + 0 ( m 2 ) per ogni permutazione iniziale della lista di m elementi, ovvero che n-l

n-1

Y_ Cj Si 2 Y_ c j + j=0

°(™2)

(3-4)

j=0

Da tale diseguaglianza segue che MTF scandisce asintoticamente non più del doppio degli , elementi scanditi da OPT quando n m 2 (scegliendo nell'analisi la specifica permutazione, per noi imprevedibile, realizzata da OPT). Nel seguito proviamo una condizione più forte di quella espressa nella diseguaglianza (3.4) da cui possiamo facilmente derivare quest'ultima: a tal fine, introduciamo la nozione di inversione. Supponiamo di aver appena eseguito l'operazione j che accede all'elemento k, e consideriamo le risultanti liste di MTF e PRM: un esempio di configurazione delle due liste in un certo istante è quello riportato nella Figura 3.9.

Presi due elementi distinti x e y in una delle due liste, questi devono occorrere anche nell'altra: diciamo che l'insieme {x, y} è un'inversione quando l'ordine relativo di occorrenza è diverso nelle due liste, ovvero quando x occorre prima di y (non necessariamente in posizioni adiacenti) in una lista mentre y occorre prima di x nell'altra lista. Nel nostro esempio, {eo,e2} è un'inversione, mentre {e], e-?} non lo è. Definiamo con il numero di inversioni tra le due liste dopo che è stata eseguita l'operazione j: vale 0 ^ cDj ^ , per 0 ^ j ^ n — 1, in quanto = 0 se le due liste sono uguali mentre, se sono una in ordine inverso rispetto all'altra, ognuno degli (™) insiemi di due elementi è un'inversione. Per dimostrare la (3.4), non possiamo utilizzare direttamente la proprietà che Cj ^ 2cJ + 0 ( 1 ) , in quanto questa proprietà in generale non è vera. Invece, ammortizziamo il costo usando il numero di inversioni
(3.5)

Possiamo derivare la (3.4) dalla (3.5) in quanto quest'ultima implica che n— 1

n—1

j=0

j=0

1 termini O nella sommatoria alla sinistra della precedente diseguaglianza formano una cosiddetta somma telescopica, (n_2) = ^ n - i ~ il> i, nella quale le coppie di termini di segno opposto si elidono algebricamente: da questa osservazione segue immediatamente che n-l n-1 ®n_i-_i + ^ c j < 2 ^ c ( j=0

(3.6)

i =0

Ponendo n _i = 0 ( m 2 ) : portando a destra del segno di diseguaglianza i primi due addendi nella (3.6), otteniamo così la disuguaglianza (3.4). Possiamo quindi concentrarci sulla dimostrazione dell'equazione (3.5), dove il caso 11 j = 0 vale per sostituzione del valore fissato per 0 _ i , in quanto 0 sia stata eseguita: a tale scopo, sia k l'elemento acceduto in seguito a tale operazione, e supponiamo che k occupi la posizione i nella lista di MTF -(per cui Cj = v): notiamo che la (3.5) è banalmente soddisfatta quando i = 0 perché la lista di MTF non cambia e, quindi, Oj =
posizione da 0 a 4, due di essi, e4 e e^, formano (assieme a un'inversione mentre i rimanenti tre elementi non danno luogo a inversioni. Q u a n d o viene posto in cima alla lista di MTF, abbiamo che gli insiemi {e3, e4} e e<$} non sono più inversioni, mentre lo diventano gli insiemi (e2,63}, (eo, e-}) e {e\, In generale, gli i elementi che precedono k nella lista di MTF sono composti da f elementi che (assieme a k) danno luogo a inversioni e da g elementi che non danno luogo a inversioni, dove f + g = i. Dopo che MTF pone k in cima alla sua lista, il numero di inversioni che cambiano sono esclusivamente quelle che coinvolgono k. In particolare, le f inversioni non sono più tali mentre appaiono g nuove inversioni, come illustrato nel nostro esempio. Di conseguenza la differenza nel numero di inversioni dopo l'operazione j è j — ® j - i = i — f + g = (f + g ) - f + g = 2g. Consideriamo ora la posizione Cj dell'elemento k nella lista di PRM: sappiamo certamente che e- > g perché ci sono almeno g elementi che precedono k, in quanto appaiono prima di k anche nella lista di MTF e non formano con k inversioni prima dell'operazione j. A questo punto, otteniamo l'equazione (3.5), in quanto Cj+Oj—Oj 1 = 2g ^ 2c-, concludendo di fatto l'analisi ammortizzata. ALVIE: liste ad auto-organizzazione

Osserva, sperimenta e verifica

MoveToFront

Osserviamo che tale analisi della strategia MTF sfrutta la condizione che l'algoritmo PRM non può manipolare la lista una volta che abbia iniziato a gestire le richieste. Purtroppo questa condizione è necessaria e la precedente analisi ammortizzata non è più valida se permettiamo anche all'algoritmo fuori linea di manipolare la sua lista: accedendo all'elemento in posizione i, l'algoritmo può ad esempio riorganizzare la lista in tempo O(i) (pensiamo a un impiegato con la sua pila disordinata di pratiche: pescata la pratica in posizione i, può metterla in cima alla pila ribaltando l'ordine delle prime i nel contempo). In particolare, è possibile dimostrare che un algoritmo fuori linea che adotta tale strategia, denominato REV, ha un costo pari a O ( n l o g n ) mentre il costo di MTF risulta essere S ( n 2 ) , invalidando l'equazione (3.4) per n sufficientemente grande. Tuttavia, MTF rimane una strategia vincente per organizzare le proprie informazioni. L'economista giapponese Noguchi Yukio ha scritto diversi libri di successo sull'organizzazione aziendale e, tra i metodi per l'archiviazione cartacea, ne suggerisce uno particolarmente efficace. Il metodo consiste nel mettere l'oggetto dell'archiviazione (un articolo, il passaporto, le schede telefoniche e così via) in una busta di carta etichettata. Le buste

sono mantenute in un ripiano lungo lo scaffale e le nuove buste vengono aggiunte in cima. Quando una busta viene presa in una qualche posizione del ripiano, identificata scandendolo dalla cima, viene successivamente riposta in cima dopo l'uso. Nel momento in cui il ripiano è pieno, un certo quantitivo di buste nel fondo viene trasferito in un'opportuna sede, per esempio una scatola di cartone etichettata in modo da identificarne il contenuto. Noguchi sostiene che è più facile ricordare l'ordine temporale dell'uso degli oggetti archiviati piuttosto che la loro classificazione in base al contenuto, per cui il metodo proposto permette di recuperare velocemente tali oggetti dallo scaffale. Possiamo facilmente riconoscere la strategia MTF nell'ordine ottenuto dal metodo di Noguchi, in base alla frequenza d'uso. In conclusione, le liste ad auto-organizzazione presentano una serie di vantaggi, in quanto hanno buone prestazioni sotto certe condizioni, sono adattive rispetto alla distribuzione delle richieste, possiedono semplici algoritmi di manipolazione e, infine, non necessitano di informazioni ausiliarie per la gestione (a parte i puntatori di lista). Come ogni altra struttura, tuttavia, presentano anche alcuni svantaggi, poiché il costo della singola operazione al caso pessimo può essere lineare e, inoltre, ogni ricerca comporta comunque una ristrutturazione della lista.

3.4.3

Tecniche di analisi ammortizzata

Le operazioni di unione e appartenenza su liste disgiunte e quelle di ricerca in liste ad auto-organizzazione non sono i primi due esempi di algoritmi in cui abbiamo applicato l'analisi ammortizzata. Abbiamo già incontrato implicitamente un terzo esempio di tale analisi per valutare il costo delle operazioni di ridimensionamento di un array di lunghezza variabile (Paragrafo 2.1.3). Questi tre esempi illustrano tre diffuse modalità di analisi ammortizzata di cui diamo una descrizione utilizzando come motivo conduttore il problema dell'incremento di un contatore. In tale problema, abbiamo un contatore binario di k cifre binarie, memorizzate in un array c o n t a t o r e di dimensione k i cui elementi valgono 0 oppure 1. In particolare, il valore del contatore è dato da ( c o n t a t o r e [ i ] x 2V) e supponiamo che esso contenga tutti 0 inizialmente. Come mostrato nel Codice 3.6, l'operazione di incremento richiede un costo in tempo pari al numero di elementi cambiati in c o n t a t o r e (righe 4 e 7), e quindi O(k) tempo al caso pessimo: discutiamo tre modi di analisi per dimostrare che il costo ammortizzato di una sequenza di n = 2 k incrementi è soltanto 0 ( 1 ) per incremento. Il primo metodo è quello di aggregazione: conteggiamo il numero totale T(n) di passi elementari eseguiti e lo dividiamo per il numero n di operazioni effettuate. Nel nostro caso, conteggiamo il numero di elementi cambiati in c o n t a t o r e (righe 4 e 7), supponendo che quest'ultimo assuma il valore iniziale pari a zero. Effettuando n incrementi, osserviamo che l'elemento c o n t a t o r e [ 0 ] cambia (da 0 a 1 o viceversa) a ogni incre-

Incrementa( contatore ): i = 0; WHILE ((i < k ) &&

(pre: V.è la dimensione di contatore)

(contatore[i] == 1) ) {

contatore[i] = 0; i = i+1;

> IF (i < k) contatore[i] = 1; Codice 3.6

Incremento di un contatore binario.

mento, quindi n volte; il valore di c o n t a t o r e [ l ] cambia ogni due incrementi, quindi n / 2 volte; in generale, il valore di c o n t a t o r e [ i ] cambia ogni 2 l incrementi e quindi n / 2 1 volte. In totale, il numero di passi è T(n) = £ i = 0 n / 2 1 = ( £ i = 0 1/2 1 )™ < 2n. Quindi il costo ammortizzato per incremento è 0 ( 1 ) poiché T ( n ) / n < 2. Osserviamo che abbiamo impiegato il metodo di aggregazione per analizzare il costo dell'operazione di unione di liste digiunte. Il secondo metodo è basato sul concetto di credito (con relativa metafora bancaria): utilizziamo un fondo comune, in cui depositiamo crediti o li preleviamo, con il vincolo che il fondo non deve andare mai in rosso (prelevando più crediti di quanti siano effettivamente disponibili). Le operazioni possono sia depositare crediti nel fondo che prelevarne senza mai andare in rosso per coprire il proprio costo computazionale: il costo ammortizzato per ciascuna operazione è il numero di crediti depositati da essa. Osserviamo che tali operazioni di deposito e prelievo di crediti sono introdotte solo ai fini dell'analisi, senza effettivamente essere realizzate nel codice dell'algoritmo cosi analizzato. Nel nostro esempio del contatore, partiamo da un contatore nullo e utilizziamo un fondo comune pari a zero. Con riferimento al Codice 3.6, per ogni incremento eseguito gestiamo i crediti come segue: 1. preleviamo un credito per ogni valore di c o n t a t o r e [ i ] cambiato da 1 a 0 nella riga 4; 2. depositiamo un credito quando c o n t a t o r e [ i ] cambia da 0 a 1 nella riga 7. Da notare che la situazione al punto 1 può occorrere un numero variabile di volte durante un singolo incremento (dipende da quanti valori pari a 1 sono esaminati dal ciclo); invece, la situazione al punto 2 occorre al più una volta, lasciando un credito per quando quel valore da 1 tornerà a essere 0: in altre parole, ogni volta che necessitiamo di un credito nel punto 1, possiamo prelevare dal fondo in quanto tale credito è stato sicuramente depositato da un precedente incremento nel punto 2. Quindi il costo ammortizzato per

incremento è 0 ( 1 ) . Possiamo applicare il metodo dei crediti per l'analisi ammortizzata del ridimensionamento di un array a lunghezza variabile: ogni qualvolta che estendiamo l'array di un elemento in fondo, depositiamo c crediti per una certa costante c > 0 (di cui uno l'utilizziamo subito); ogni volta che raddoppiamo la dimensione dell'array, ricopiando gli elementi, utilizziamo i crediti accumulati fino a quel momento. Infine, il terzo metodo è basato sul concetto di potenziale (con relativa metafora fisica). Numerando le n operazioni da 0 a n — 1, indichiamo con 0 _ i il potenziale iniziale e con
- c D j _ ,

C j

Quindi, il costo totale che ne deriva è dato da ^ " J o 1

(3.7)

=

(ci +

~~

=

1

^ j ^ Cj + ( ® n _ i — ): utilizzando il fatto che otteniamo una somma telescopica per le differenze di potenziale, deriviamo che il costo totale per la sequenza di n operazioni può essere espresso in termini del costo ammortizzato nel modo seguente: n— 1 Cj

j=0

n— 1 = ^ c

j

+ (0„1-cDn_1)

(3.8)

j=0

Nell'esempio del contatore binario, poniamo uguale al numero di valori pari a 1 in c o n t a t o r e dopo il (j + l)-esimo incremento, dove 0 ^ j ^ n — 1: quindi, O i = 0 in quanto il contatore è inizialmente pari a tutti 0. Per semplicità, ipotizziamo che il contatore contenga sempre uno 0 e, fissato il (j + 1 )-esimo incremento, indichiamo con £ il numero di volte che viene eseguita la riga 4 nel ciclo w h i l e del Codice 3.6: il costo è quindi Cj = £ + 1 in quanto £ valori pari a 1 diventano 0 e un valore pari a 0 diventa 1. Inoltre, la differenza di potenziale ®j — ® j - i misura quanti 1 sono cambiati: ne abbiamo £ in meno e 1 in più, per cui Ì > j — — ì = —£-{-\. Utilizzando la formula (3.7), otteniamo un costo ammortizzato pari a Cj = ( £ + 1) + (—£+ 1) = 2. Poiché ® n _ i ^ 0 e = 0, in base all'equazione (3.8) abbiamo che ^ ^ J Q 1 Cj ^ ^ 2n. Osserviamo che abbiamo utilizzato il metodo del potenziale per l'analisi della strategia MTF scegliendo come potenziale ®j il numero di inversioni rispetto alla lista gestita da PRM. ALVIE: p r o b l e m a del c o n t a t o r e b i n a r i o

Osserva, sperimenta e verifica BinaryCounter

RIEPILOGO In questo capitolo abbiamo descritto come realizzare le operazioni di ricerca, inserimento e cancellazione all'interno di una lista, considerando anche le varianti relative a liste doppie e circolari. Abbiamo poi mostrato un'applicazione di array e liste per la risoluzione del problema dei matrimoni stabili. Infine, abbiamo ripreso il concetto di algoritmo random mostrando una realizzazione efficiente di una lista a salti e abbiamo introdotto il concetto di analisi ammortizzata, considerando la gestione dell'unione di liste disgiunte e quella di liste ad auto-organizzazione. ESERCIZI 1. Mostrate come modificare il Codice 3.1, utilizzando un ulteriore riferimento q in modo tale che valga la seguente invariante, necessaria a implementare l'operazione di cancellazione in una lista semplice: se entrambi p e q puntano allo stesso elemento, questo è il primo della lista; altrimenti, p e q . s u c c puntano allo stesso elemento nella lista, e tale elemento è diverso dal primo elemento della lista. 2. Mostrate le istruzioni necessarie a inserire un nuovo elemento in cima a una lista doppia e quelle necessarie per le operazioni di inserimento e cancellazione in una lista circolare. 3. Dimostrate che utilizzando una lista semplice per implementare l'algoritmo round robin, esistono sequenze di operazioni che richiedono tempo O(n) per operazione, invece che tempo 0 ( 1 ) . 4. Descrivete un'implementazione dell'algoritmo insertion sort che utilizzi liste anziché array, identificando il tipo di lista adatto a ottenere, per ogni sequenza di n dati in ingresso, un costo computazionale uguale a quello dell'implementazione basata su array (ricordiamo che per alcune sequenze quest'ultima ha complessità temporale 0 ( n ) ) . 5. E possibile implementare l'algoritmo di risoluzione del problema dei matrimoni stabili facendo uso esclusivamente di array e mantenendo la complessità temporale 0 ( n 2 ) ? Giustificate la risposta. 6. Mostrate che, nonostante sia costo(MTF) ^ 2 x costo(OPT), alcune configurazioni hanno costo(MTF) < costo(OPT) (prendete una lista di m = 2 elementi e accedete a ciascuno n / 2 volte). 7. Consideriamo un algoritmo fuori linea REV, il quale applica la seguente strategia ad auto-organizzazione per la gestione di una lista. Quando REV accede all'elemento in posizione i, va avanti fino alla prima posizione i ' ^ i che è una potenza

del 2, prende quindi i primi i ' elementi e li dispone in ordine di accesso futuro (ovvero il successivo elemento a cui accedere va in prima posizione, l'ulteriore successivo va in seconda posizione, e così via). Ipotizziamo che n = m = 2 k + 1 per qualche k > 0, che inizialmente la lista contenga gli elementi eo, ..., em-i e che la sequenza di richieste sia eo, e \ , . . . , e m _ i , in questo ordine (vengono cioè richiesti gli elementi nell'ordine in cui appaiono nella lista iniziale). Dimostrate che il costo di MTF risulta essere 0 ( n 2 ) mentre quello di REV è O ( n l o g n ) . Estendete la dimostrazione al caso n > m. 8. Calcolate un valore della costante c adoperata nell'analisi ammortizzata con i crediti per il ridimensionamento di un array di lunghezza variabile, dettagliando come gestire i crediti.

Capitolo 4

Alberi

SOMMARIO In questo capitolo descriviamo come organizzare i dati in strutture gerarchiche introducendo le nozioni di albero binario, albero cardinale e albero ordinale. Discutiamo inoltre una metodologia generale di progettazione degli algoritmi ricorsivi su alberi e le varie modalità di visita (anticipata, simmetrica, posticipata e per ampiezza). L'opus libri del capitolo consiste in una soluzione efficiente del problema del minimo antenato comune. Infine, descriviamo come rappresentare in modo implicito e succinto gli alberi al fine di ottenere un risparmio della memoria occupata. DIFFICOLTÀ 1,5 CFU.

4.1

Alberi binari

Gli alberi rappresentano una generalizzazione delle liste nel senso che, mentre ogni elemento delle liste ha al più un successore, ogni elemento degli alberi può avere più di un successore. Come vedremo, gli alberi sono solitamente utilizzati per rappresentare partizioni ricorsive di insiemi e strutture gerarchiche: un tipico utilizzo di alberi per rappresentare gerarchie è fornito dagli alberi genealogici, in cui ciascun nodo dell'albero rappresenta una persona della famiglia i cui figli sono ad esso collegati da un arco ciascuno. Ad esempio, nella Figura 4.1, è mostrata una parte dell'albero genealogico della famiglia Baggins di Hobbiville, quella relativa ai discendenti di Largo (corrispondente alla radice dell'albero), il cui unico figlio è Fosco, i cui nipoti sono Dora, Drogo, e Dudo, e i cui pronipoti sono Frodo e Daisy. Come possiamo osservare, ogni nodo dell'albero ha associata la lista (eventualmente vuota) dei figli: utilizzando una terminologia che è un misto di genealogia e botanica,

Figura 4.1

I discendenti di Largo Baggins di Hobbiville.

chiamiamo foglie i nodi senza figli, e nodi interni i rimanenti nodi. Allo stesso tempo, l'albero associa a tutti i nodi, eccetto la radice, un unico genitore, detto padre: i nodi figli dello stesso padre sono detti (rateili. Osserviamo che, ad ogni nodo interno, è anche associato il sottoalbero di cui tale nodo è radice. Se un nodo u è la radice di un sottoalbero contenente un nodo v, diciamo che u è un antenato di v e che v è un discendente di u. Ad esempio, nella Figura 4.1 consideriamo il nodo Drogo il cui sottoalbero contiene, oltre a se stesso, il suo unico figlio Frodo. Il padre di Drogo è Fosco e i suoi fratelli sono Dora e Dudo. Infine, Drogo è discendente di Largo, che è suo antenato. Gli alberi genealogici sono spesso utilizzati anche per rappresentare l'insieme degli antenati di una persona, anziché quello dei suoi discendenti: in tali alberi i figli di un nodo rappresentano, in modo apparentemente contraddittorio, i suoi genitori. Nella Figura 4.2 sono, ad esempio, rappresentati gli antenati (noti agli autori) di Frodo Baggins. Questo tipo di albero, rispetto a quello visto in precedenza, presenta due principali caratteristiche: ogni nodo ha al più due figli e ogni figlio ha un ruolo ben determinato che dipende dall'essere il figlio sinistro oppure il figlio destro (in particolare, il figlio sinistro indica il padre mentre il figlio destro rappresenta la madre). Chiamiamo albero binario un albero siffatto, che può essere definito ricorsivamente nel modo seguente: un albero vuoto è un albero binario che non contiene alcuna chiave

Figura 4.2

L'albero degli antenati di Frodo Baggins.

e che viene indicato con n u l i , analogamente a quanto fatto con la lista vuota. Un albero binario (non vuoto) contenente n elementi è costituito dalla radice r, che memorizza uno di questi elementi mettendolo "a capo" degli altri; i rimanenti n — 1 elementi sono divisi in due gruppi disgiunti, ricorsivamente organizzati in due sottoalberi binari distinti, etichettati come sinistro e destro e radicati nei due figli ts e r o della radice. Notiamo che uno o entrambi i nodi Ts e TD possono essere n u l i , a rappresentare sottoalberi vuoti, e che i figli di una foglia sono entrambi uguali a n u l i , così come il padre della radice dell'albero. Un albero binario viene generalmente rappresentato nella memoria del calcolatore facendo uso di tre campi. In particolare, dato un nodo u, indichiamo con u . d a t o il contenuto del nodo, con u . s x il riferimento al figlio sinistro e con u . dx il riferimento al figlio destro UD (talvolta ipotizzeremo che sia anche presente un riferimento u . p a d r e al padre del nodo). Ad esempio, nella Figura 4.3 (in cui tre sottoalberi sono solo tratteggiati e non esplicitamente disegnati) mostriamo come viene rappresentata la parte superiore dell'albero

dato

sx

Frodo Baggins

/

dx

V

px

/

Ti Primula Brandibuck

V

Ruby Bolgeri

Figura 4.3

/

\

/

J

La rappresentazione della parte superiore dell'albero genealogico nella Figura 4.2.

genealogico illustrato nella Figura 4.2: osserviamo, tuttavia, che nel seguito preferiremo sempre fare riferimento alla rappresentazione grafica semplificata di quest'ultima figura.

4.1.1

Algoritmi ricorsivi su alberi binari

Gli alberi binari, essendo definiti in modo ricorsivo, permettono di progettare algoritmi ricorsivi seguendo una metodologia generale di risoluzione: nel discuterne alcuni esempi, introdurremo anche della terminologia aggiuntiva che, sebbene fornita per semplicità con riferimento agli alberi binari, è in generale applicabile anche ad alberi di tipo diverso, quali quelli considerati nel Paragrafo 4.3. Un parametro che caratterizza un albero è la sua dimensione n, data dal numero di nodi in esso contenuti: chiaramente, un albero di dimensione n ha esattamente n — 1 archi (che collegano un qualunque nodo diverso dalla radice al padre), come possiamo notare nell'esempio di Figura 4.2. Osserviamo che la dimensione di un albero binario può essere definita ricorsivamente nel modo seguente: un albero vuoto ha dimensione 0, mentre la dimensione di un albero non vuoto è pari alla somma delle dimensioni dei suoi sottoalberi, incrementata di 1, per includere la radice. Il Codice 4.1 utilizza tale osservazione per realizzare un algoritmo che determina la dimensione di un albero binario. Se l'albero è vuoto, la sua dimensione è pari a 0 (riga 3). Se non lo è, le due chiamate ricorsive calcolano la dimensione dei sottoalberi radicati nei

Dimensione( u ): IF (u == nuli) { RETURN 0; > ELSE

{

dimensioneSX = Dimensione( u.sx ); dimensioneDX = Dimensione( u.dx ); RETURN dimensioneSX + dimensioneDX + 1;

C o d i c e 4.1

Algoritmo ricorsivo per il calcolo della dimensione di un albero binario.

figli (righe 5-6): di tali dimensioni viene restituita come risultato la somma incrementata di 1 (riga 7). Un altro parametro caratteristico di un albero è la sua altezza: per definire tale parametro, notiamo che l'ordine gerarchico esistente tra i nodi di un albero permette di classificarli in base alla loro profondità. La radice r ha profondità 0, i suoi figli r$ e TD hanno profondità 1 (se diversi da n u l i ) , i nipoti hanno profondità 2 e così via. In generale, se la profondità di un nodo è pari a p, allora i suoi figli non vuoti (ovvero diversi da n u l i ) hanno profondità p + 1. Il seguente frammento (iterativo) di codice calcola la profondità di un nodo, fermandosi alla radice quando il riferimento al padre è n u l i . p = 0; WHILE (U.padre != nuli) {

p = p + 1; u = u.padre ;

> L'altezza h. di un albero è data dalla massima profondità raggiunta dalle sue foglie. Quindi, l'altezza misura la massima distanza di una foglia dalla radice dell'albero, in termini del numero di archi attraversati. E inefficiente calcolare esplicitamente tutte le profondità iterando il suddetto frammento di codice per ogni foglia dell'albero, prendendone poi la massima per trovare l'altezza. Infatti, uno stesso nodo u può essere attraversato molte volte per calcolare tali profondità, ovvero tante quante sono le foglie discendenti di u. Poiché la definizione di altezza si applica anche ai sottoalberi, è più efficiente e semplice trovare l'altezza di un albero binario osservando che l'albero composto da un solo nodo ha altezza pari a 0, mentre un albero con almeno due nodi ha altezza pari all'altezza del suo sottoalbero più alto, incrementata di 1 in quanto la radice introduce un ulteriore livello (da cui deriviamo che l'albero vuoto ha altezza pari a —1). Il Codice 4.2 utilizza tale osservazione per realizzare un algoritmo che determina l'altezza di un albero. Come possiamo osservare, se usiamo l'accorgimento di considerare

Altezza( u ): IF (u == nuli) { RETURN -1; } ELSE {

altezzaSX = Altezza( u.sx ); altezzaDX = Altezza( u.dx ); RETURN max( altezzaSX, altezzaDX ) + 1;

}• Codice 4.2

(post: restituisce — 1 se e solo se u è nuli) Algoritmo ricorsivo per il calcolo dell'altezza di un albero binario.

come caso base l'albero vuoto, otteniamo che il codice segue lo stesso schema del Codice 4.1 e, inoltre, che l'altezza calcolata per le foglie risulta correttamente pari a 0 (in quanto sottoalberi composti da un solo nodo): di conseguenza, per induzione è corretta anche l'altezza calcolata per tutti i sottoalberi. Nello specifico, il Codice 4.2 opera nel modo seguente: se l'albero è vuoto, la sua altezza è pari a —1 (riga 3). Se non lo è, le due chiamate ricorsive calcolano l'altezza dei sottoalberi radicati nei figli (righe 5-6): di tali altezze viene restituita come risultato la massima incrementata di 1 (riga 7). Sia il Codice 4.1 che il Codice 4.2 hanno quindi un caso base (albero vuoto) e un passo induttivo (albero non vuoto) in cui avvengono le chiamate ricorsive. A parte le differenze sintattiche dovute al fatto che i due codici calcolano quantità differenti, la struttura computazionale è identica: ciascuna invocazione restituisce un valore (l'altezza o la dimensione), che possiamo facilmente dedurre nel caso base di un albero vuoto. Nel passo induttivo, deleghiamo il calcolo delle rispettive quantità alla ricorsione sui due figli (sottoalberi): una successiva fase di combinazione di tali quantità, restituite dalle chiamate ricorsive sui figli, contribuisce a ottenere il risultato per il nodo corrente. Tale risultato va a sua volta restituito mediante l'istruzione r e t u r n , per far sì che l'induzione si propaghi attraverso la ricorsione: infatti, chi invoca le chiamate ricorsive deve a sua volta trasmettere il risultato così ottenuto. ALVIE:

a l t e z z a di un albero binario

Osserva, sperimenta e verifica BinaryTreeHeight

o

Non è difficile applicare lo schema ricorsivo appena delineato al calcolo del numero di foglie discendenti: in realtà, molti problemi su alberi possono essere risol-

Decomponibile(u): IF (u == nuli) { RETURN Decomponibile(nuli); > ELSE {

risultatoSX = Decomponibile(u.sx); risultatoDx = Decomponibile(u.dx); RETURN Ricombina(risultatoSX, risultatoDx);

Codice 4.3

Algoritmo ricorsivo per risolvere un problema decomponibile su alberi binari.

ti analogamente, con varianti più o meno sofisticate. Tali problemi sono detti decomponibili, in quanto caratterizzabili secondo il paradigma del divide et impera: sia D e c o m p o n i b i l e ( u ) il valore da calcolare relativamente al sottoalbero radicato nel nodo u (ad esempio la sua dimensione o il numero di foglie in esso contenute). Per sfruttare il paradigma del divide et impera, dobbiamo individuare i seguenti punti focali nella definizione di D e c o m p o n i b i l e ( u ) . Caso base: stabilire il valore di D e c o m p o n i b i l e ( u ) quando u = n u l i (anche se alcune volte è più semplice definire tale valore quando u è una foglia). Decomposizione: riformulare il problema per il sottoalbero radicato in un nodo u in termini di quelli radicati nei suoi figli Us e u q . Ricombinazione: trovare la regola R i c o m b i n a che permette di ricombinare i valori D e c o m p o n i b i l e ( u s ) e D e c o m p o n i b i l e f u o ) in modo da ottenere il valore Decomponibile(u). Nel caso del Codice 4.2, D e c o m p o n i b i l e ( u ) è l'altezza del sottoalbero radicato in u: il caso base è rappresentato dalla riga 3 mentre il passo induttivo ha come regola di combinazione quella riportata nella riga 7. Nel Codice 4.1, D e c o m p o n i b i l e ( u ) è la dimensione del sottoalbero radicato in u: il caso base è rappresentato dalla riga 3 mentre il passo induttivo ha come regola di combinazione quella riportata nella riga 7 di tale codice. Fatte le dovute premesse, possiamo fornire un codice generale per risolvere problemi decomponibili su alberi (Codice 4.3), che ricalca lo schema ricorsivo finora usato. Notiamo che ogni nodo viene attraversato un numero costante di volte, per cui se il caso base e la regola R i c o m b i n a richiedono tempo costante, l'esecuzione richiede un tempo totale O(n). Lo schema del Codice 4.3 permette di effettuare una visita di un albero binario a partire dalla sua radice. La visita equivale a esaminare tutti i nodi in modo sistematico, una e una sola volta, analogamente alla scansione di sequenze lineari, dove procediamo dall'inizio alla fine o viceversa. Per semplicità, durante la visita facciamo corrispondere

Anticipata( u ): IF (u != nuli) { PRINT u.dato;

Anticipata( u.sx ); Anticipata( u.dx );

> Codice 4 . 4

Visita anticipata di un albero binario. Le altre due visite, simmetrica e posticipata, sono ottenute spostando l'istruzione di stampa dalla riga 3 a una delle due righe successive.

l'esame di un nodo all'operazione di stampa del suo contenuto. Tale visita permette di operare varie scelte che dipendono dall'ordine con cui viene esaminato l'elemento memorizzato nel nodo corrente e vengono invocate le chiamate ricorsive nei suoi figli. Visita anticipata (preorder): stampa l'elemento contenuto nel nodo; visita ricorsivamente il sottoalbero sinistro; visita ricorsivamente il sottoalbero destro. Visita simmetrica (inorder): visita ricorsivamente il sottoalbero sinistro; stampa l'elemento contenuto nel nodo-, visita ricorsivamente il sottoalbero destro. Visita posticipata (postorder): visita ricorsivamente il sottoalbero sinistro; visita ricorsivamente il sottoalbero destro; stampa l'elemento contenuto nel nodo. Il costo di ciascuna delle tre visite è O(n) per un albero di dimensione n (cambia soltanto l'ordine con cui l'elemento nel nodo corrente viene stampato). Il codice per tali visite è una semplice variazione del Codice 4.3 (che rappresenta una visita posticipata in cui non viene restituito alcun valore). Per esempio, il Codice 4.4 realizza la visita anticipata: osserviamo che non restituisce alcun valore in questa forma e che può essere trasformato nel codice di una visita simmetrica o posticipata molto semplicemente, spostando l'istruzione di stampa (riga 3). Per apprezzare la differenza delle tre visite, consideriamo l'esempio mostrato nella Figura 4.4, in cui oltre alle tre visite suddette viene illustrato anche il risultato di una quarta visita che illustreremo più avanti.

ALVIE:

visita posticipata di un albero binario

Osserva, sperimenta e verifica BinaryTreePostorder

Tornando allo schema del Codice 4.3, possiamo notare che esso rappresenta un modo di effettuare una visita posticipata in cui viene raccolta l'informazione necessaria alla

anticipata: FB

D

B

RB

PB

GB

M

B

FB

M

B

G

B

A

B

A

B

G

B

G

RB

G

B

M

A

B

M

T

G

T

P

B

MT

G

T

T

M

T

PB

FB

T

M

B

A

G

simmetrica: D

B

RB

posticipata: R

B

D

B

M

B

ampiezza: F

Figura 4.4

B

D

B

PB

B

T

Risultato delle visite di un albero binario.

computazione di D e c o m p o n i b i l e ( u ) , a partire dal basso verso l'alto. Per risolvere alcuni problemi decomponibili, è necessario raccogliere più informazione di quanta ne serva apparentemente: studiamo, ad esempio, il caso degli alberi completamente bilanciati. Un albero binario è completo se ogni nodo interno ha esattamente due figli non vuoti. L'albero è completamente bilanciato se, oltre a essere completo, tutte le foglie hanno la stessa profondità. Un albero completamente bilanciato di altezza h. ha quindi 2 h — 1 nodi interni e 2h foglie: ne deriva che la relazione tra altezza h. e numero di nodi n = 2 h + 1 — 1 è h = log(n + 1) — 1. Possiamo introdurre la definizione di albero binario bilanciato: in tale albero vale la relazione h. = O(logn), che risulta essere interessante per la complessità delle operazioni fornite da diverse strutture di dati. Notiamo che un albero completamente bilanciato è bilanciato, mentre il viceversa non sempre vale. Volendo usare lo schema del Codice 4.3 per stabilire se un albero binario è completamente bilanciato, possiamo valutare cosa succede ipotizzando che D e c o m p o n i b i l e ( u ) sia un valore booleano, che risulta T R U E se e solo se T(u) è completamente bilanciato, dove T(u) indica l'albero radicato in u . Indicati come al solito con e con u p i due figli di u , il fatto che T ( u s ) e T(UQ ) siano completamente bilanciati, non comporta purtroppo che anche T(u) lo sia, in quanto i due sottoalberi potrebbero avere altezze diverse: in altre parole, T(u) è completamente bilanciato se e solo se T ( u s ) e T(U.D ), oltre a essere completamente bilanciati, hanno anche la stessa altezza. Nel Codice 4.5 richiediamo che D e c o m p o n i b i l e ( u ) sia una coppia di valori, in cui il primo è T R U E se e solo se T(u) è completamente bilanciato, mentre il secondo è l'altezza di T(u) (calcolata come nel Codice 4.2). La regola R i c o m b i n a diventa quindi quella riportata di seguito.

CompletamenteBilanciatoC u ): IF (u == nuli) { RETURN ; > ELSE {

= CompletamenteBilanciatoC u.sx ); = CompletamenteBilanciatoC u.dx ); completamenteBil = bilSX && bilDX && CaltSX == altDX); altezza = maxCaltSX, altDX) + 1; RETURN


} [post: restituisce T R U E come prima componente «-• T(u) è completamente bilanciato) Codice 4.5

Algoritmo ricorsivo per stabilire se un albero binario è completamente bilanciato.

• La prima componente di D e c o m p o n i b i l e ( u ) è TRUE se e solo se lo sono le prime componenti di D e c o m p o n i b i l e f u s ) e di D e c o m p o n i b i l e ( u D ) e se le seconde componenti sono uguali (riga 7). • La seconda componente di D e c o m p o n i b i l e ( u ) è uguale al massimo tra le seconde componenti di D e c o m p o n i b i l e f u s ) e di D e c o m p o n i b i l e f u o ) incrementato di 1 (riga 8) ALVIE: albero binario c o m p l e t a m e n t e bilanciato

Osserva, sperimenta e verifica FullyBalancedTree

Cjr-: ©

Per completare il quadro dello schema generale riportato nel Codice 4.3, discutiamo un algoritmo ricorsivo su alberi binari, in cui le chiamate non solo raccolgono informazione dai sottoalberi, ma propagano simultaneamente informazione proveniente dagli antenati, passando opportuni parametri alle chiamate. Un problema di questo tipo riguarda l'identificazione dei nodi cardine. Dato un nodo u , sia p u la sua profondità e h. u l'altezza di T(u). Diciamo che u è un nodo cardine se e solo se p u = b u . Vogliamo progettare un algoritmo ricorsivo che stampi il contenuto di tutti i nodi cardine presenti in un albero binario. In questo caso, possiamo presumere che D e c o m p o n i b i l e ( u ) = h u , analogamente al Codice 4.1: tuttavia, al momento di invocare la chiamata ricorsiva su u dobbiamo garantire di passare p u come parametro. Il Codice 4.6 ha quindi due parametri in ingresso per questo scopo: il primo indica il nodo corrente e il secondo la sua profondità.

Cardine ( u, p ) : IF (u == nuli) {

(pre: p èia profondità di u)

RETURN -1 ; > ELSE {

altezzaSX = Cardine( u.sx, p+1 ); altezzaDX = Cardine( u.dx, p+1 ); altezza = max( altezzaSX, altezzaDX ) + 1; IF (p == altezza) PRINT u.dato; RETURN altezza;

}• Codice 4.6

(post: stampa i nodi cardine di T(u)) Algoritmo ricorsivo per individuare i nodi cardine in un albero binario. La chiamata iniziale ha come parametri la radice e la sua profondità pari a 0.

Inizialmente, questi parametri sono la radice r dell'albero e la sua profondità p r = 0. Le successive chiamate ricorsive provvedono a passare i parametri richiesti (righe 5 e 6): ovvero, se il nodo corrente ha profondità p, i figli avranno profondità p + 1. La verifica che la profondità sia uguale all'altezza nella riga 8 stabilisce infine se il nodo corrente è un nodo cardine: in tal caso, la sua informazione viene stampata. Da notare che la complessità temporale dell'algoritmo rimane O(n) in quanto si tratta di una semplice variazione della visita posticipata implicitamente adottata nel Codice 4.3. ALVIE:

nodi cardine di un albero binario

Osserva, s p e r i m e n t a e verifica HingeNode

4.1.2

Inserimento e cancellazione

Analogamente alle liste, gli alberi binari si prestano a essere mantenuti dinamicamente in modo efficiente. Osserviamo che una lista può essere rappresentata come un albero degenere in cui i nodi u hanno uno dei due campi, u . s x oppure u . d x , sempre uguale a n u l i . La testa della lista coincide quindi con la radice dell'albero degenere. Ne deriva che l'altezza di un albero binario può essere h. = n — 1 in tali casi degeneri (confrontiamo questo con il valore di h. = O(logn) nel caso di alberi bilanciati). Nel seguito, ipotizziamo che ogni nodo contenga il riferimento al padre (in tal caso, l'albero degenere è una lista doppia). L'operazione dinamica più semplice è quella di

p

=

u.padre

z.sx

=

u;

z.dx

=

nuli;

u.padre

=

z;

z.padre

=

p;

IF r >

>

(p

==

=

z;

ELSE

IF

p.sx

=

ELSE

{

p.dx

=

nuli)

(u

==

{

p.sx)

{

z;

z;

> Codice 4.7

Inserimento di un nuovo padre z (con il campo z . d a t o già inizializzato) del nodo u, che ne diventa figlio sinistro. Gli assegnamenti nelle righe 2-3 vanno invertiti per rendere u figlio destro di z.

inserire o cancellare un figlio. Sostituiamo un figlio di u, per esempio quello sinistro, con il nuovo figlio v a cui va aggiornato il riferimento al padre. Il seguente frammento di codice descrive un inserimento se u . s x è vuoto prima delle operazioni descritte, mentre descrive una cancellazione se u . s x non è vuoto (supponiamo che i campi v . d a t o , v . s x e v . d x siano stati già correttamente inizializzati dall'applicazione di riferimento). u . s x = v; IF (v != n u l i ) v . p a d r e = u; Un'operazione analoga è quella di inserire un nuovo padre z per un nodo u, ipotizzando di avere anche il riferimento r alla radice dell'albero binario. Ai fini della discussione, supponiamo che il nuovo padre abbia u come figlio sinistro (non è difficile modificare le righe 2 - 3 del Codice 4.7 per rendere u un figlio destro), e che il campo z . d a t o sia già stato correttamente inizializzato dall'applicazione di riferimento. Nel Codice 4.7, stabiliamo prima il vecchio padre di u, indicato con p nella riga 1 (p è n u l i quando u è la radice r dell'albero binario). Nelle righe 2—4, u diventa figlio sinistro di z, il nuovo padre. Le righe rimanenti rendono p (o il riferimento r se p è n u l i ) padre di z. In particolare, il confronto nella riga 6 permette di stabilire se r è il padre di z, mentre quello nella riga 8, permette a z di prendere il posto di u come figlio di p. In ogni caso, il costo totale dell'inserimento è 0 ( 1) tempo. Infine, mostriamo la cancellazione del padre di u quando u è figlio unico. In tal caso, le operazioni da eseguire sono riportate nel Codice 4.8, dove presumiamo che il padre di u non sia n u l i (altrimenti non procediamo con la cancellazione). Dopo aver

p = u.padre; pp = p . p a d r e ; u . p a d r e = pp; IF (pp == n u l i ) { r = u; } ELSE IF (p == p p . s x ) { p p . s x = u; } ELSE { pp.dx = u;

> Codice 4.8

Cancellazione del padre p del nodo u (dove p è diverso da n u l i e il fratello di u è uguale a n u l i ) .

individuato il nonno di u nelle prime due righe ed aver aggiornato in u il riferimento al nuovo padre, nella terza riga, le righe successive stabiliscono se il padre di u sia la radice 0 meno. Se lo è, allora u diviene la nuova radice, altrimenti u prende il posto del padre come figlio del nonno: osserviamo come le righe 3 - 1 0 siano analoghe alle righe 5 - 1 2 del Codice 4.7. Anche in questo caso, il costo è O( 1 ) tempo. Per concludere, osserviamo che altre operazioni dinamiche sono possibili, ma queste vanno discusse contestualmente all'applicazione di riferimento.

4.2

Opus libri: minimo antenato comune

In molte situazioni reali, i dati che devono essere elaborati sono statici (non subiscono modifiche nel corso del tempo) e possono quindi essere organizzati in un'opportuna struttura di dati in modo tale che le successive richieste siano efficientemente eseguite. In altre parole, siamo disposti a pagare un prezzo, in termini di tempo, per pre-elaborare 1 dati a disposizione (preprocessing), per poi rispondere molto velocemente a future richieste relative ai dati stessi (query). In questo paragrafo vediamo un esempio di tale approccio per la risoluzione di un noto problema su alberi. Dato un albero degli antenati, una domanda naturale consiste nel determinare chi sia il primo erede comune di due qualunque persone presenti nell'albero: facendo riferimento alla Figura 4.2, ad esempio, il primo erede comune di Marmadoc Brandibuck e di Adamanta Paffuti è Primula Brandibuck, mentre il primo erede comune di Drogo Baggins e Mirabella Tue è Frodo Baggins. Rispondere a tale domanda è equivalente a saper calcolare, dati due nodi u. e v di un albero, l'antenato comune di u e v che si trova più lontano dalla radice dell'albero: tale antenato è comunemente denominato minimo antenato comune. Il Codice 4.9 riporta le istruzioni necessarie a identificare tale an-

MinimoAntenatoComune ( u, v ) :

{pre: Il campo prof contiene la profondità)

WHILE (u.prof != v.prof) {

IF (u.prof > v.prof) { u = u.padre; > ELSE {

v = v.padre;

>

>

IF (u == v ) RETURN U; WHILE (u.padre != v.padre) {

u = u.padre; v = v.padre;

> RETURN

Codice 4.9

u.padre;

Ricerca del minimo antenato comune tra due nodi u e v.

fenato. A tal fine, ipotizziamo che ogni nodo sia dotato di un ulteriore campo p r o f contenente la sua profondità nell'albero (abbiamo visto nel paragrafo precedente come calcolare, per ogni nodo dell'albero, il valore di tale campo). Dopo aver risalito parte del cammino dal nodo di profondità maggiore verso la radice, i due nodi correnti si trovano alla stessa profondità (righe 2—8). A questo punto, abbiamo due possibilità: 1. abbiamo già raggiunto il minimo antenato comune, in quanto un nodo era discendente dell'altro (riga 9); 2. dobbiamo risalire in parallelo i due cammini verso la radice fino a che il minimo antenato comune risulti essere il padre di entrambi i nodi correnti (righe 10-13). Il costo temporale di tale algoritmo è proporzionale alla massima profondità tra u e v, per cui il costo al caso pessimo è O(h) tempo per un albero di altezza h. Uno scenario più interessante si presenta quando vogliamo rispondere a molte richieste di ricerca del minimo antenato comune. Ad esempio, un tale scenario si presenta nelle scienze economiche e manageriali per ottimizzare il flusso di informazioni nell'organizzazione delle reti gerarchiche (di comunicazione, sociali ed economiche). Tali reti sono rappresentate come alberi nella loro struttura principale e i nodi hanno importanza diversa in base alla quantità di informazione che devono scambiare con il resto dei nodi (tale importanza non è necessariamente collegata all'ordine gerarchico indotto dall'albero). Alle coppie di nodi critici, attivamente impiegate in flussi di vaste dimensioni, vengono aggiunti degli ulteriori collegamenti per creare canali diretti di comunicazione preferenziale, identificandone i minimi antenati comuni che sono i loro colli di bottiglia.

Eulero ( u, p ) : IF (u != nuli) {

{pre: p è la profondità di u)

PRINT p;

IF (u.sx != nuli) { Eulero( u.sx, p+1 ); PRINT p;

> IF (u.dx != nuli) { Eulero( u.dx, p+1 ); PRINT p;

>

> Codice 4.10

Stampa ricorsiva delle profondità dei nodi di un albero secondo il suo ciclo Euleriano. La chiamata iniziale ha come argomenti la radice r e la sua profondità p r = 0.

Nel caso di molte richieste, è pertanto preferibile dedicare tempo polinomiale di calcolo per effettuare un preprocessing dell'albero, così da poter rispondere successivamente alla sequenza di query sul minimo antenato comune in modo molto efficiente. Questo problema è generalmente indicato con l'acronimo LCA (dall'inglese Least Common Ancestor) e risulta essere uno strumento fondamentale per risolvere altri problemi, come vedremo in alcuni dei capitoli successivi. Il problema LCA è introdotto nel modo seguente: pre-elaborare un albero binario in tempo polinomiale così che sia possibile, dati due nodi qualunque u e v dell'albero, determinare in tempo costante il minimo antenato comune di u e v. Una soluzione immediata a tale problema per un albero di dimensione n e altezza h. deriva dalla costruzione di un array bidimensionale t di n righe e n colonne, tale che t[u][v] memorizza il risultato restituito da M i n i m o A n t e n a t o C o m u n e f u , v). Tale fase di preprocessing richiede 0(n 2 h.) tempo. Il vantaggio è che ora ogni successiva query richiede 0 ( 1 ) tempo. Tuttavia, lo spazio occupato è 0 ( n 2 ) celle di memoria a causa della dimensione dell'array t prodotto dal preprocessing. Per ridurre tale spazio a O ( n l o g n ) celle, mantenendo un tempo costante di query, operiamo una trasformazione del problema LCA nel problema della ricerca del minimo valore all'interno di un segmento di un array di numeri interi.

4.2.1

Trasformazione da antenati comuni a minimi in intervalli

La tecnica di trasformare un problema computazionale TT i in un altro problema computazionale n 2 è probabilmente una delle più comunemente utilizzate per progettare algoritmi di risoluzione. Intuitivamente, tale tecnica consiste nel mostrare come le soluzioni

Marmadoc Brandibuck

Figura 4 . 5

\ 1 Adaldrida Bolgeri

•

/

Gerontius Tue

Cammino Eleuriano di una porzione dell'albero degli antenati della Figura 4.2.

per Fi2 possano essere efficientemente impiegate per ottenere le soluzioni di FI) (vedremo nell'ultimo capitolo del libro una trattazione più formale del concetto di riduzione). Nel caso in questione, mostriamo come trasformare LCA nel problema RMQ (dall'inglese Range-Min Query) così definito: pre-elaborare in tempo polinomiale un array a di n numeri interi, così che sia possibile, dati due indici i e j, determinare in tempo costante l'indice del minimo elemento contenuto nel segmento a[i, j] (lo spazio totale deve essere di O ( n l o g n ) celle di memoria). Dato un albero (ovvero un'istanza del problema LCA), definiamo il ciclo Euleriano dell'albero attraverso una visita ricorsiva dei suoi nodi come illustrato nel Codice 4.10. In tale codice, le profondità dei nodi sono stampate secondo l'ordine indicato dalle frecce nella Figura 4.5 (in cui l'albero utilizzato è una porzione dell'albero degli antenati mostrato nella Figura 4.2): a partire dalla radice, i nodi sono visitati la prima volta quando ci muoviamo dai padri ai figli (frecce verso il basso) e sono poi visitati nuovamente quando ci muoviamo dai figli ai padri (frecce verso l'alto). Modificando in modo opportuno il Codice 4.10, ogni qualvolta un nodo viene visitato, possiamo aggiungere la sua profondità a un array di numeri interi, mantenendo al contempo un collegamento bidirezionale tra il nodo e il nuovo elemento dell'array (osserviamo che a ogni nodo dell'albero corrispondono al più tre elementi dell'array). Ad esempio, l'array risultante dalla visita dell'albero mostrato nella Figura 4.5 è illustra-

.S •= -e •= .5 DO « oa

0 a,

1 £

Figura 4.6

2

a> o 2

^

Q

B!

Q

0

1

2

1

0

1

2

3

2

3

2

0

1

2

3

4

5

6

7

8

9

10 11 12 13 14 15 16

UH

1

2

3

2

1

0

L'array corrispondente al cammino Euleriano della Figura 4.5.

to nella Figura 4.6. Osserviamo che la costruzione dell'array richiede tempo lineare nel numero di nodi dell'albero. Una volta costruito l'array, possiamo notare che il minimo antenato comune di due nodi u e v dell'albero è semplicemente il nodo con la profondità minima che si trova all'interno del segmento delimitato dalle prime due occorrenze dei due nodi nell'array. Ad esempio, supponiamo di voler trovare il minimo antenato comune di Marmadoc Brandibuck e di Mirabella Tue: la prima occorrenza nell'array di Marmadoc Brandibuck si ha in corrispondenza dell'indice 7, mentre la prima occorrenza di Mirabella Tue appare in corrispondenza dell'indice 12. Tra queste due occorrenze il nodo con profondità minima è quello corrispondente all'elemento di indice 11: in effetti, il minimo antenato comune di Marmadoc Brandibuck e di Mirabella Tue è Primula Brandibuck. In modo analogo, possiamo verificare che il minimo antenato comune di Ruby Bolgeri (indice 2) e Marmadoc Brandibuck (indice 7) è Frodo Baggins (indice 4). L'osservazione è valida in generale, in quanto supponendo che u venga visitato per la prima volta prima di v, il tratto di ciclo Euleriano che va da u a v attraversa una serie di nodi di cui il loro antenato comume minimo è quello con profondità minima. Abbiamo così dimostrato che il problema di rispondere in tempo costante a una qualunque query di tipo LCA, è riducibile al problema di rispondere in tempo costante a un'opportuna query di tipo RMQ. Possiamo quindi concentrarci su quest'ultimo problema, ponendoci come obiettivo di mantenere lo spazio a O ( n l o g n ) celle.

4.2.2

Soluzione efficiente in spazio

Dato un array a di n numeri interi, la soluzione quasi lineare del problema RMQ consiste nel considerare solamente la famiglia dei segmenti di a aventi una potenza del 2 come

RMQ( i , j ) : p* = p [ j - i + l ] ; q* = q C p * ] ;

mi = b[p*] [ i ] ; m2 = b[p*] [ j - q * + l ] ; IF (a[ml] < A[m2] ) { RETURN MI; > ELSE { RETURN M2;

> Codice 4.11

2° 21 22 23 24

0 0 0 0 0 0

Figura 4 . 7

Query per il problema RMQ.

1 1 1 4 4 4

2 2 3 4 4

3 3 4 4 4

4 4 4 4 4

5 5 5 5 5

6 6 6 6 11

7 7 8 8 11

8 8 8 11 11

9 9 10 11 16

10 10 11 11

11 11 11 11

12 12 12 15

13 13 14 16

14 14 15

15 15 16

16 16

La tabella b per la soluzione del problema RMQ in spazio O(nlogn).

lunghezza, e nel memorizzare il minimo elemento di ciascun segmento. Osserviamo che, per ogni indice i compreso tra 0 e n — 1, vi sono al più logn segmenti di tale famiglia, per cui lo spazio richiesto risulta essere O ( n l o g n ) celle di memoria. A tal fine il preprocessing richiede la costruzione di un array bidimensionale b di logn righe e n colonne, in cui b[l][i] contiene la posizione del minimo elemento nel segmento a[i,i + 2 l — 1], dove ' ° g n 0 a tabella mostrata nella Figura 4.7, costruita a partire dall'array mostrato nella Figura 4.6, mostra gli elementi minimi in corrispondenza a segmenti che rientrano interamente nei limiti dell'array). La costruzione di b richiede tempo O ( n l o g n ) utilizzando, per ogni l con logn, la seguente regola di programmazione dinamica chiamata del raddoppio. Caso base: poiché il minimo elemento all'interno di un segmento di lunghezza 2° = 1 coincide con l'unico elemento del segmento stesso, b[0][v] = i per 0 ^ i ^ n — 1. Passo induttivo: osserviamo che un segmento a[i, i + 2 l + 1 — 1] con l ^ 0, è interamente contenuto nell'array a solo se i + 2 l + 1 - 1 ^ n - 1, ovvero se i ^ n - 2 l + 1 . In tal caso, il minimo elemento in a[i, i + 2 l + 1 - 1] può essere calcolato confrontando

il minimo elemento all'interno della metà destra del segmento con il minimo elemento all'interno della metà sinistra. Quindi, b[l+l][i] = min{b[l][i], b[l][i+2 l ] per 0 ^ i ^ n — 2 l + 1 . Il preprocessing richiede la costruzione di due ulteriori array: l'array p di n numeri interi, tale che p[x] = l se e solo se 2 l è la più grande potenza del 2 minore o uguale a x (in altre parole, p[x] = [logxj), e l'array q di logn numeri interi, tale che q[l] = 2 l . Il tempo totale e lo spazio per il preprocessing sono quindi O ( n l o g n ) (ma è possibile ridurre lo spazio a O(n) celle di memoria). Per gestire una query di RMQ relativa a un segmento a[i, }] di lunghezza x = j — i + 1, calcoliamo p* = p[x] e q* = q[p*] = 2P* in tempo costante, e troviamo i due indici ttl] = b[p*][i] e m.2 = b[p*][j — q* + 1] che indicano la posizione degli elementi minimi nei due corrispondenti segmenti di lunghezza q* che ricoprono a[i, j] (un segmento è a[i, i + q * — 1] e l'altro è a[j — q* + 1,j]). Come già notato, il minimo in a[i, j] è il minimo tra i due elementi a[mi] e a[m2l: il Codice 4.11 si basa su tale sequenza di operazioni. Ad esempio, supponiamo di voler determinare il valore minimo contenuto all'interno del segmento a[7,12] dell'array mostrato nella Figura 4.6: in tal caso, x = 12 — 7 + 1 = 6, per cui p* = 2 e q* = 4 . Pertanto, possiamo consultare la tabella mostrata nella Figura 4.7 per determinare l'indice del valore minimo contenuto all'interno del segmento a[7,10]: l'elemento della tabella che ci interessa si trova in terza riga (in quanto il segmento ha lunghezza 4) e in ottava colonna (in quanto il segmento ha inizio dall'elemento di indice 7) ed è uguale a 8. Analogamente, utilizzando la tabella possiamo dedurre che l'indice del valore minimo contenuto all'interno del segmento a[9,12] è pari a l i . Poiché a[8] = 2 > 1 = Q[1 1], concludiamo che la risposta alla nostra interrogazione è l i . ALVIE: minimo antenato comune <2E>

Osserva, sperimenta e verifica LeastCommonAncestor

4.3

®

^¡^

_

Visita per ampiezza e rappresentazione di alberi

Abbiamo già osservato che, in molte applicazioni, le strutture di dati utilizzate risultano essere statiche, non subendo modifiche nel corso del tempo. Nel caso degli alberi, un esempio concreto è dato dal formato di scambio denominato XML (Extensible Markup Lartguage), il cui vasto utilizzo in molte applicazioni permette di memorizzare dati strutturati. I documenti in formato XML descrivono un albero i cui nodi sono etichettati

Figura 4.8

Una rappresentazione XML dell'albero genealogico mostrato nella Figura 4.3.

con attributi e valori: per esempio, uno dei modi per esprimere la porzione di albero mostrata nella Figura 4.3 in formato XML è quello riportato nella Figura 4.8. Questo utile formato occupa più spazio di quanto richiesto a causa della sua verbosità: poiché viene usato per rappresentare grandi quantità di dati, è necessario codificarlo in forma compressa mantenendo la sua struttura originale (in tal modo, il risparmio di spazio si traduce in una compressione dei dati memorizzati). Le etichette (nel nostro esempio, i nomi delle persone) sono memorizzate in una zona di memoria contigua usando opportune tecniche di compressione testuale (ad esempio, sfruttando la ridondanza di un qualunque linguaggio naturale). Per quanto riguarda, invece, la struttura ad albero, ovvero i riferimenti ai figli, è utile comprimerla a patto di simulare tali riferimenti in tempo costante: la caratteristica di questa metodologia è di permettere l'attraversamento dell'albero compresso senza decodificarne l'intera struttura ogni volta.

In questo paragrafo consideriamo due diverse metodologie (quella implicita e quella succinta) di compressione per gli alberi binari statici, in cui ipotizziamo che il campo u . d a t o (l'etichetta del nodo) occupi uno spazio prefissato di memoria indipendentemente dal nodo u di appartenenza e che il contenuto di u . d a t o sia già fornito compresso. In tal modo, possiamo concentrarci sul risparmio di spazio per memorizzare i riferimenti u . p a d r e , u . s x e u . dx in forma implicita o succinta. L'idea è di allocare un albero binario in un array secondo l'ordine derivante da una visita in ampiezza dei suoi nodi (un esempio di tale visita è riportato nella Figura 4.4). Ogni nodo u viene così associato concettualmente alla sua posizione nell'array (occupata dal campo chiave u . d a t o ) . In particolare, identificheremo il nodo u con il corrispondente elemento dell'array e, per attraversare l'albero dai padri ai figli e viceversa, utilizzeremo una rappresentazione indiretta dei riferimenti u . p a d r e , u . s x e u . dx, che saranno simulati calcolando le posizioni nell'array del padre, del figlio sinistro e del figlio destro di u, rispettivamente. Anticipiamo sin da ora, che mentre nella rappresentazione implicita (utilizzabile solo in alcune classi di alberi binari) usiamo soltanto l'array dei nodi e un numero costante di celle di memoria aggiuntive, nella rappresentazione succinta tale array è affiancato da ulteriori strutture di dati che richiedono 2n + o(n) bit aggiuntivi: in compenso, quest'ultima rappresentazione è applicabile ad alberi binari qualunque. Abbiamo addotto il notevole risparmio di spazio per motivare tali rappresentazioni, per cui cerchiamo di quantificarne il vantaggio. Ipotizzando che ciascun riferimento ( u . p a d r e , u . s x , u . d x ) sia allocato in una cella di memoria (di 32 o 64 bit), la rappresentazione succinta permette di sostituire i circa 100 bit (o più) occupati da tali campi con all'incirca due bit per nodo: ne deriva un risparmio in spazio che è quasi un cinquantesimo (o più) della rappresentazione esplicita dei riferimenti! In generale, se ciascun riferimento in un albero binario di dimensione n richiede logn bit (il minimo necessario per indicare uno qualunque dei nodi), la rappresentazione succinta sostituisce i 3 n l o g n bit usati dalla rappresentazione esplicita della struttura dell'albero, con soli 2n + o(n) bit (ricordiamo che la rappresentazione implicita è superiore in prestazioni ma meno generale e che i campi u . d a t o vengono compressi con altre tecniche).

4.3.1

Rappresentazione implicita di alberi binari

La relazione tra i nodi u di un albero binario in una rappresentazione implicita è codificata completamente tramite una semplice regola matematica senza alcun uso di memoria aggiuntiva, a parte quella necessaria alle chiavi u . d a t o e a un numero costante di variabili locali. L'albero binario completo a sinistra è l'esempio principe di albero rappresentabile in modo implicito. Un albero binario di altezza h. è completo a sinistra se i nodi di profondità minore di h. formano un albero completamente bilanciato, e se i nodi di ( profondità h. sono tutti accumulati a sinistra (parte sinistra della Figura 4.9). Possiamo verificare facilmente che h. = [lognj = O(logn), dove n è il numero di nodi.

padre

i 0

1

3

PB

FB

4

Rappresentazione implicita di un

6

RB G B 1

Figura 4.9

5

7

I£

FB D B

2

8 LB

9 Ts X Y

sx dx

completo a sinistra.

Dato un albero binario completo a sinistra possiamo memorizzare in un array i suoi nodi, effettuando una visita per ampiezza operata a partire dalla radice, come mostrato nel Codice 4.12: la caratteristica di tale visita è che essa memorizza i nodi in ordine crescente di profondità p nell'array n o d o (la cui lunghezza presumiamo che sia uguale alla dimensione dell'albero binario), a partire dalla radice: inoltre, i nodi di profondità p sono memorizzati a partire dalla posizione u l t i m o + 1, procedendo da sinistra verso destra. Dopo aver memorizzato la radice dell'albero (righe 3—4), iteriamo fintanto che non vi sono più nodi da visitare (riga 5). Preso il nodo nella posizione a t t u a l e (riga 6), aggiungiamo nelle posizioni immediatamente successive a quella indicata da u l t i m o i suoi figli non vuoti (righe 7 - 1 4 ) . Per dimostrare che tutti i nodi sono visitati, osserviamo che ogni qualvolta un nodo viene visitato, i suoi figli sono memorizzati in n o d o e, da quel momento in poi, u l t i m o è maggiore oppure uguale alla loro posizione nell'array. Quindi, se la condizione della riga 5 non è verificata, allora non vi sono più nodi da visitare. Notando inoltre che, a ogni iterazione del ciclo w h i l e , il valore di a t t u a l e aumenta di 1, abbiamo che il costo è O(n) tempo, dove n indica la dimensione dell'albero. La Figura 4.9 riporta un esempio di tale memorizzazione dei nodi di un albero binario completo a sinistra in un array: osserviamo che i soli campi u . d a t o sono effettivamente memorizzati. Pur avendo ignorato i campi u . p a d r e , u . s x e u . d x , la relazione gerarchica viene comunque preservata: è infatti sufficiente esaminare, nell'array, la posizione corrispondente a ciascun nodo. La radice occupa la posizione i = 0. In generale, se l'albero ha dimensione n e un suo generico nodo u occupa la posizione i, possiamo associare le posizioni dell'array ai tre riferimenti u . s x , u . dx e u . p a d r e con la regola: • il figlio sinistro occupa la posizione 2i + 1 (se 2v + 1 ^ n , allora u . s x = n u l i ) ; • il figlio destro occupa la posizione 2i + 2 (se 2i + 2 ^ n , allora u.dx = n u l i ) ; • il padre occupa la posizione |_(i — 1 )/2J (se i = 0, allora u . p a d r e = n u l i ) .

Implicita( u, nodo ): (pre: \iè la radice dell'albero e la lunghezza di nodo è uguale al numero dei suoi nodi) ultimo = attuale = 0; nodo[attuale] = u; WHILE (attuale <= ultimo) { u = nodo[attuale]; IF (u.sx != nuli) { nodo[ultimo+1] = u.sx; ultimo = ultimo +1;

> IF (u.dx ! = nuli) -C nodo[ultimo+1] = u.dx; ultimo = ultimo +1;

} attuale = attuale+1;

> Codice 4.12

Memorizzazione in un array dei nodi di un albero binario completo a sinistra mediante una visita per ampiezza.

La navigazione nell'albero da un nodo ai suoi figli, e viceversa, richiede quindi tempo costante come nella rappresentazione esplicita. Nell'ottica del risparmio di memoria, la rappresentazione implicita è preferibile perché usa soltanto 0 ( 1 ) celle di memoria aggiuntive, quindi O(logn) bit, oltre allo spazio necessariamente richiesto per la memorizzazione dei campi u . d a t o . Osserviamo che tale rappresentazione non può essere usata per alberi binari qualunque (a meno di non sfruttare una qualche relazione tra le chiavi dei campi u . d a t o ) , come possiamo dedurre dall'albero mostrato nella parte sinistra della Figura 4.10. In base alla regola matematica appena esposta, l'unico figlio del nodo in posizione 1 dovrebbe occupare la posizione 4, mentre esso viene memorizzato in posizione 3 dalla visita in ampiezza realizzata dal Codice 4.12: in questo caso, la regola non vale cosi come è formulata, ma è possibile raffinare l'idea mediante l'introduzione della rappresentazione succinta. ALVIE:

rappresentazione implicita ®

Osserva, sperimenta e verifica ImplicitRepresentation

®®® ®®

®

"

0 1 2 3 4 5 6 7 8 9 10 11 12 1 1 1 0 1 0 0 1 1 0 0 0 0 (PB)

F

B

D

B

P

B

-

RB

X

Y

Z

Y

1 F b D b PbRBXYZY ,1 1 1 0 1 0 0 1 nodo[0,n-l].dato Figura 4.10

4.3.2

10000

pieno[0,2n]

Rappresentazione succinta per ampiezza di un albero binario con n nodi.

Rappresentazione succinta per ampiezza

Nell'ottica del risparmio di memoria per un albero binario qualunque, utilizziamo una rappresentazione succinta, il cui scopo è quello di rappresentare la struttura dell'albero (senza sfruttare proprietà particolari delle chiavi) utilizzando 2n + o(n) bit in aggiunta allo spazio occupato dai campi u . d a t o . In particolare, riprendendo l'esempio mostrato nella Figura 4.10, modifichiamo il Codice 4.12 in modo che produca un ulteriore array binario p i e n o contenente i bit pari a 1 in corrispondenza dei nodi dell'albero e i bit pari a 0 in corrispondenza dei riferimenti n u l i (tale modifica è illustrata nel Codice 4.13). Come possiamo osservare nell'esempio nella Figura 4.10, esiste una corrispondenza biunivoca tra i nodi dell'albero e i bit pari a 1 in p i e n o : ricordando che nodo[i] memorizza l'(i + 1)-esimo nodo u visitato per ampiezza (0 ^ i < n — 1), abbiamo che esso corrisponde all'fi + 1 )-esimo 1 nell'array p i e n o e viceversa. In base a tale corrispondenza, l'array p i e n o permette di stabilire la seguente regola, analoga a quella introdotta per la rappresentazione implicita: 1. se un nodo occupa la posizione i nell'array nodo, allora i bit corrispondenti ai suoi due figli occupano le posizioni 2i + 1 e 2i + 2 nell'array p i e n o ; 2. se un nodo occupa la posizione i nell'array nodo, allora p i e n o [ 2 i + 1] = 1 se solo se il riferimento al suo figlio sinistro non è n u l i e p i e n o [ 2 i + 2] = 1 se solo se il riferimento al suo figlio destro non è n u l i . Tale regola può essere verificata per ispezione diretta nella Figura 4.10. Per convincerci della sua correttezza in generale, osserviamo che l'invariante mantenuta dal ciclo w h i l e nel Codice 4.13 è che il valore di u l t i m o P i e n o è pari a due volte il valore di a t t u a l e : chiaramente ciò è vero prima dell'inizio del ciclo (poiché entrambi i valori sono 0); inoltre, l'invariante è mantenuta a ogni iterazione, in quanto il valore di a t t u a l e

SuccintaAmpiezza( u, nodo, pieno ): (pre: u radice di albero di n nodi; lunghezze di nodo e pieno sono n e 2n + 1) ultimoNodo = ultimoPieno = 0; nodo[ultimoNodo] = u; pieno[ultimoPieno] = 1; attuale = 0; WHILE (attuale <= ultimoNodo) { u = nodo[attuale]; IF (u.sx != nuli) { nodo[ultimoNodo+1] = u.sx; ultimoNodo = ultimoNodo + 1; pieno[ultimoPieno + 1 ] = 1 ; > ELSE {

pieno[ultimoPieno + 1 ] = 0 ;

> IF (u.dx != nuli) { nodo[ultimoNodo+1] = u.dx; ultimoNodo = ultimoNodo + 1; pieno[ultimoPieno + 2 ] = 1; > ELSE {

pieno[ultimoPieno + 2 ] = 0 ;

> attuale = attuale + 1; ultimoPieno = ultimoPieno + 2;

Codice 4.13

Rappresentazione succinta per ampiezza di un albero binario.

è incrementato di 1 e quello di u l t i m o P i e n o è incrementato di 2. Da ciò deriva che se un nodo occupa la posizione a t t u a l e in nodo, allora i bit corrispondenti ai suoi due figli occupano nell'array p i e n o le posizioni u l t i m o P i e n o + 1 = 2 x a t t u a l e + 1 (riga 12 o 14) e u l t i m o P i e n o + 2 = 2 x a t t u a l e + 2 (riga 19 o 21). Abbiamo così dimostrato il punto 1 della suddetta regola. Per dimostrare il punto 2, osserviamo che, quando un nodo u. viene esaminato dalla visita in ampiezza (riga 8), se un figlio di u esiste, allora il bit a esso corrispondente è posto a 1 (riga 12 o 19), altrimenti tale bit è posto a 0 (riga 14 o 21). La regola suddetta permette di navigare da un nodo u ai suoi figli e viceversa, mantenendo i soli campi u . d a t o in n o d o e associandoli ai corrispettivi bit pari a 1 in p i e n o . Per poter passare in tempo costante dalle posizioni di n o d o a quelle dei corrispondenti 1 in p i e n o e viceversa, utilizziamo due funzioni basilari per le strutture di dati succinte, una inversa dell'altra, definite su un array b di m bit (nel nostro caso, b è l'array p i e n o

Select

1 L F B D B P B RB XY Z Y , 1 1 1 0 1 0 0 1 1 0 0 0 0 pieno nodo Rank Figura 4.11

Uso di Rank e S e l e c t per mettere in corrispondenza gli elementi di nodo con i corrispettivi bit in pieno.

e m = 2 n + 1 come mostrato nella Figura 4.11): • Rank(b,i) = numero di 1 presenti nel segmento b[0,i], per 0 ^ i ^ m — 1; • S e l e c t ( b , i) = posizione dell'(i + 1 )-esimo 1 in b, per 0 ^ i < Rank(b, m — 1 ). Il Codice 4.14 mostra come navigare nell'albero binario utilizzando l'array nodo, le funzioni Rank e S e l e c t applicate all'array p i e n o e la regola discussa prima. Per esempio, per identificare la posizione nell'array n o d o del figlio sinistro di nodo[i], prima identifichiamo la sua posizione f = 2 i + 1 nell'array p i e n o ; poi, usiamo R a n k ( p i e n o , f) per vedere quanti 1 sono presenti nel segmento p i e n o [ 0 , f], deducendo che il figlio sinistro si trova in n o d o [ R a n k ( p i e n o , f) — 1], Per trovare il padre di nodo[i], è sufficiente identificare la posizione p = S e l e c t f p i e n o , i) del bit 1 corrispondente a nodo[i] nell'array p i e n o ; invertendo la regola, otteniamo che n o d o [ [ ( p — 1)/2J] contiene il padre di nodo[i]. Per calcolare lo spazio aggiuntivo rispetto a quello occupato dall'array nodo, dobbiamo conteggiare i 2 n + 1 bit necessari per memorizzare l'array p i e n o , e lo spazio necessario per realizzare le funzioni Rank e S e l e c t , che ora mostreremo essere O ( n l o g l o g n / l o g n ) = o(n) bit. Quindi, la rappresentazione succinta utilizza un totale di 2 n + o(n) bit aggiuntivi per la rappresentazione di un qualunque albero binario.

4.3.3

Implementazione di rank e select

La funzione Rank per un array b di m bit può essere implementata usando o(m) bit aggiuntivi: per illustrare il metodo adottato, consideriamo ad esempio un array di m = 256 bit, i cui primi 13 bit corrispondano a quelli dell'array p i e n o riportato nella Figura 4.10. Partiamo dalla rappresentazione esplicita di Rank, tabulando i suoi valori in un array: b[i] i Rank

1 0 1

1 1 2

1 2 3

0 3 3

1 4 4

0 5 4

0 6 4

1 7 5

1 8 6

0 9 6

0 10 6

0 11 6

0 12 6

0 13 6

0 14 6

0 15 6

••• •••

IndiceFiglioSinistro( i ): f = 2 x i + 1; IF (pieno [f] == 0) { RETURN nuli; > ELSE {

RETURN Rank( pieno, f ) - 1;

} IndiceFiglioDestro( i ): f = 2 x i + 2; IF (pieno[f] == 0) { RETURN nuli; > ELSE {

RETURN Rank( pieno, f ) - 1;

> IndicePadre( i ): IF (i == 0) { RETURN nuli; > ELSE {

p = Select( pieno, i ); RETURN

(p - 1) / 2;

> Codice 4.14

Simulazione dei riferimenti sx, dx e padre per nodo[i]. Tali riferimenti, se diversi da n u l i , restituiscono la posizione del corrispondente elemento nell'array nodo.

Tale rappresentazione permette un tempo costante di calcolo, ma richiede un'occupazione di memoria eccessiva, in quanto contiene m interi di l o g m bit ciascuno. Per ridurre lo spazio, partizioniamo b in segmenti elementari di k = j l o g m bit ciascuno (k = 4 nell'esempio). Inoltre, manteniamo un solo valore di Rank per ogni segmento elementare, cosi che dobbiamo memorizzare solo m / k = 2 m / log m interi di log m bit ciascuno in un array r ' , per un totale di 2 m bit: r'[j] j b[i] i Rank

1 0 1

1 1 2

1 2 3

3 1 0 3 3

1 4 4

0 5 4

0 6 4

5 2 1 7 5

1 8 6

0 9 6

0 10 6

6 3 0 11 6

0 12 6

0 13 6

0 14 6

6 4 0 15 6

... ••• •••

Se dobbiamo restituire uno dei valori in r ' , possiamo chiaramente farlo in tempo costante. Ma cosa succede se dobbiamo restituire un valore Rank(b,i) non "campionato"? Usiamo la proprietà che ogni valore non campionato può essere espresso come la som-

ma del valore campionato più vicino a partire da sinistra (ovvero, r ' [i/k] supponendo che r'[0] = 0) e del numero di bit pari a 1 nella porzione di segmento elementare che contiene b[i]. Per esempio, Rank(b,6) = r'[l] + (numero di 1 nei primi tre bit di b[4,7]) = 3 + 1 = 4 Per calcolare il numero di 1 nei primi bit di ciascun segmento elementare, costruiamo una volta per tutte un array bidimensionale c, le cui colonne corrispondono a tutti i possibili 2 k segmenti elementari di k bit e le cui righe corrispondono a tutte le possibili k posizioni all'interno di un segmento elementare. Questo array contiene tutte le risposte alle richieste che possono essere eseguite sui primi bit di un segmento elementare, come mostrato nella Figura 4.12: usando c, possiamo dunque calcolare Rank(b,6) = r'[l] + c[2][9] = 3 + 1 = 4, in quanto il segmento b[4,7] = 1 , 0 , 0 , 1 corrisponde alla colonna 9 e i suoi primi tre bit terminano nella posizione j = 2. L'osservazione fondamentale, nota come trucco dei quattro russi, è che non ci possono essere troppi segmenti elementari distinti: precisamente, il loro numero è 2 k = x/rrT- Ne deriva che l'array c contiene soltanto k x 2 k = CH^TU logm) elementi di O(logk) bit, e quindi utilizza o(m) bit. A questo punto, per calcolare Rank(b,i) in tempo costante usando solo r ' , c e i segmenti elementari di b, è sufficiente restituire r'[q] + c[r][s], dove q e r sono il quoziente e il resto della divisione tra i e k, e s rappresenta il (q + 1)esimo segmento elementare di b. Mentre è ovvio che q = [_i/k.J e r = i — kq possono essere calcolati in tempo costante, non altrettanto facile è calcolare s in tempo costante (in effetti, se eseguissimo un semplice algoritmo di conversione da binario a decimale, questo richiederebbe tempo O(k) = O(logm)). Possiamo a tale scopo sostituire b con un vettore b ' contenente m / k interi tale che b'[j] è uguale al numero intero rappresentato dalla sequenza di bit del (j + l)-esimo segmento di b (notiamo che 0 ^ b'[j] < V/TTI): r'[j] j b'[j] i Rank

0 1

1 2

2 3

3 1 14 3 3

4 4

5 4

6 4

5 2 9 7 5

8 6

9 6

10 6

6 3 8 11 6

12 6

13 6

14 6

6 4 0 15 ••• 6

Pertanto, Rank(b,i) = r'[q] + c[r][b'[q + 1]]: ad esempio, Rank(b,6) = r'[l] + c[2][b'[2]] = r ' [ l ] + c[2][9] = 4 . In realtà abbiamo ancora troppi valori tabulati in r', in quanto questi richiedono 2m bit in totale. Introduciamo allora un ulteriore livello di campionamento, tabulando solo un valore di Rank ogni j log2 m bit consecutivi, memorizzando tali valori in un array r " di soli 8 m / l o g 2 m x logm = 0 ( m / l o g m ) bit (la scelta di g è semplicemente dovuta al fatto di poter proseguire in questo modo l'esempio).

— O ~ o O —. o O O O — ' — O O — 'O — — oO O— — « O O—' O ———' O O OO O O —O. O O—. O O O— O I O ——' — O — ' O

H= 0 h= 1 h = 2 h= 3 Figura 4.12

0 0 0 0

0 0 0 1

0 0 1 1

0 0 1 2

0 1 1 1

0 1 1 2

0 1 2 2

0 1 2 3

1 1 1 1

1 1 1 2

1 1 2 2

1 1 2 3

1 2 2 2

1 2 2 3

1 2 3 3

1 2 3 4

L'array c per il numero di 1 contenuti nelle prime h. posizioni di tutti i possibili segmenti elementari.

A q u e s t o p u n t o , p a r t i z i o n i a m o b in b l o c c h i d a g log 2 m bit e d i v i d i a m o o g n i b l o c c o in s e g m e n t i e l e m e n t a r i , c o s t r u e n d o l'array r ' a esso relativo (in altre parole, è c o m e se avessimo u n array T ' p e r o g n i blocco): r" r' Rank b i

1 1 0

2 1 1

3 1 2

3 3 0 3

4 1 4

4 0 5

4 0 6

5 5 5 1 7

6 1 8

6 0 9

6 0 10

1 6 0 11

6 0 12

6 0 13

6 0 14

6 1 6 0 15

•••

N e deriva c h e le s o m m e parziali in r ' h a n n o valore al p i ù g l o g 2 m e, q u i n d i , ciascun e l e m e n t o di r ' richiede o r a s o l t a n t o 0 ( l o g l o g m ) bit: p e r t a n t o , lo spazio o c c u p a t o d a r ' è O ( m l o g l o g m / l o g m ) bit. S o m m a n d o a n c h e lo spazio di r " e c, o t t e n i a m o o ( m ) bit in a g g i u n t a agli m bit richiesti da b (in realtà d a b ' ) .

Per calcolare R a n k ( b , i ) in

t e m p o c o s t a n t e u s a n d o b ' , r ' , r " e c, o s s e r v i a m o c h e i identifica u n u n i c o b l o c c o e u n u n i c o s e g m e n t o e l e m e n t a r e al s u o i n t e r n o : q u i n d i , R a n k ( b , i ) è, c o m e p r i m a , pari alla s o m m a r ' [ q ] + c[r][b'[q + 1]] a cui p e r ò a g g i u n g i a m o il valore c a m p i o n a t o di R a n k per il blocco c o r r e n t e , ovvero r " [ t ] dove t = 8 i / l o g m ( n e l l ' e s e m p i o , R a n k ( b , 12) = r " [ l ] + r ' [ 3 ] + c[1][0] = 5 + 1 + 0 = 6). Tali o p e r a z i o n i r i c h i e d o n o u n t e m p o c o s t a n t e ciascuna e d e t e r m i n a n o il c o s t o finale di u n ' i n v o c a z i o n e a R a n k . L'operazione S e l e c t ha u n a realizzazione a livelli simile a quella di R a n k , a n c h e se l e g g e r m e n t e p i ù sofisticata in q u a n t o la p a r t i z i o n e di b in s e g m e n t i e l e m e n t a r i è adattiva rispetto al n u m e r o di 1 in essi c o n t e n u t i . ALVIE: rappresentazione succinta per a m p i e z z a

Osserva, sperimenta e verifica BreadthRepresentation



®

cE>

4.3.4

Limite inferiore allo spazio delle rappresentazioni succinte

Nei paragrafi precedenti abbiamo mostrato come costruire una rappresentazione succinta che richiede 2n + o(n) bit aggiuntivi: in questo paragrafo, dimostriamo che questa quantità non è significativamente migliorabile per un qualunque albero binario, secondo la seguente argomentazione tratta dalla teoria dell'informazione. Prendiamo un insieme di C oggetti distinti. Per indicarne uno qualunque, non possiamo usare meno di k = flogC] bit (per esempio, abbiamo bisogno di almeno k = 2 bit per distinguere C = 3 oggetti). Se così non fosse, basterebbero k' < k bit ma confonderemmo due oggetti distinti poiché 2 k ' ^ < C, generando una contraddizione: in generale, occorrono k = [log C] bit per rappresentare un qualunque oggetto appartenente all'insieme di C oggetti. Nel nostro caso, gli oggetti da considerare sono gli alberi binari di dimensione n e l'obiettivo è quello di valutare il minimo numero di bit necessari per rappresentare in modo distinto alberi diversi. Sia C n il numero di alberi binari distinti con n nodi (equivalentemente, gli alberi binari con n nodi interni, dove ciascuno ha due figli). Tale quantità è nota come numero di Catalan, C n = ( 2 T [ l )/(n + 1 ) : quindi, occorrono [logC n ] bit per rappresentare un qualunque albero binario con n nodi. La regola ricorsiva con cui otteniamo C n è intuitiva: togliendo la radice da un albero binario di n nodi, i rimanenti nodi costituiscono il sottoalbero sinistro di dimensione s (dove O ^ s ^ n — 1 ) e il sottoalbero destro di dimensione n — s — 1. Ne deriva che il numero C n di alberi binari distinti con n nodi soddisfa l'equazione ricorsiva n— 1 Cn = ^ ( C s=0

s

x Cn_s_,)

(dove Co = Ci = 1)

(4.1)

in quanto possiamo combinare tutti i possibili C s sottoalberi sinistri con tutti i possibili C n _ s _ i sottoalberi destri, per ogni valore di s. La soluzione dell'equazione di ricorrenza (4.1) è il numero di Catalan C n = ( 2 ^ ) / ( n + 1): la dimostrazione di ciò richiede tecniche di analisi combinatoria che possono essere facilmente trovate nella letteratura specializzata. Per valutare quindi k = [~logCn~|, osserviamo che 2n^ n /

_

—

(2n)! 2n 2 n x (2n - 1 ) x (2n — 2 ) x - - - x 3 x 2 x l n!n! 2n n x n x ( n — l)x(n— 1 ) x • • •x 1 x 1 1 2nx2n (2n - 1) x (2n - 2) 3x2 X X - X • • •x 2n nxn (n-l)x(n—1) lxl 1 ^ 2 n x 2n ^ (2n — 2) x (2n — 2) ^ ^2x2 2n nxn (n — l ) x ( n — 1) lxl

=

1 22n — x 2s x 2 x 2 x 2 x - - - 2 x 2 = —— 2n v ' 2n 2 n volte

AnticipataC u ): IF (u != nuli) { PRINT u.dato; FOR (i = 0; i < k; i = i+1)

AnticipataC u.figlio[i] );

> Codice 4.15

Visita anticipata di un albero k-ario, derivata dal Codice 4.4.

dove la diseguaglianza deriva dal fatto che 2 n — i > 2 n — i — 1 per ogni i > 0. Concludiamo che k = [ l o g C a l = l o g f ( 2 ^ ) / ( n + l ) ] > l o g [ 2 2 r v / ( 2 n ( n + 1))] = 2 n - 0 ( l o g n ) bit sono necessari. Abbiamo quindi stabilito un limite inferiore all'occupazione in spazio di una qualunque rappresentazione succinta di un albero binario: quella che abbiamo proposto nei paragrafi precedenti risulta dunque essere ottima a meno di un termine o(n) di ordine inferiore. Ricordiamo comunque che, per insiemi particolari di alberi binari, possono esistere rappresentazioni che richiedono meno di 2 u — O(logn) bit (come osservato, ad esempio, nel caso di alberi completi a sinistra).

4.4

Alberi cardinali e ordinali, e parentesi bilanciate

Gli alberi binari finora discussi sono un caso particolare degli alberi cardinali o k-ari, caratterizzati dal fatto che ogni nodo ha k riferimenti ai figli, i quali sono enumerati da 0 a k — 1. Precisamente, un nodo u di un albero k-ario ha i campi u . d a t o e u . p a d r e come negli alberi binari, mentre i riferimenti ai suoi figli sono memorizzati in un array u . f i g l i o di dimensione k, dove u . f i g l i o l i ] è il riferimento (eventualmente uguale a n u l i ) al figlio i (0 ^ i < k - 1): per k = 2, abbiamo che u . f i g l i o [0] corrisponde a u . s x mentre u . f i g l i o [ 1 ] corrisponde a u . d x . Per k = 3 , 4 , . . . , si ottengono alberi ternari, quaternari e così via, che possono essere definiti ricorsivamente come gli alberi binari: la maggior parte delle definizioni relative agli alberi binari si adattano facilmente agli alberi cardinali. Per esempio, un albero k-ario è completo se ogni nodo interno ha tutti i k figli non vuoti: inoltre, è completamente bilanciato se tutte le foglie sono alla stessa profondità. L'altezza h. di un albero k-ario completamente bilanciato soddisfa la relazione 1 + k + k 2 + k 3 + • • • + k h = n sul numero n di nodi: quindi, risulta h. = O(log k n) in quanto _

kh+l — 1

2-1=0^ k-i • Gli algoritmi ricorsivi per gli alberi binari si estendono facilmente agli alberi k-ari. Per esempio, la visita anticipata del Codice 4.4 dà luogo al Codice 4.15 in cui, attraverso un ciclo aggiuntivo, visitiamo ricorsivamente tutti i figli del nodo corrente.

Figura 4 . 1 3

Due alberi binari distinti che risultano indistinguibili come alberi ordinali.

Gli alberi ordinali si differenziano da quelli cardinali, in quanto ogni nodo memorizza soltanto la lista ordinata dei riferimenti non vuoti ai suoi figli. Il numero di tali figli è variabile da nodo a nodo e viene chiamato grado: il grado è un intero compreso tra 0 (nel caso di una foglia) e n — 1 (nel caso di una radice che ha i rimanenti nodi come figli), e un nodo di grado d > 0 ha d figli che sono numerati consecutivamente da 0 a d — 1. Un esempio è mostrato nella Figura 4.1 dove il grado massimo (denominato grado dell'albero) è d = 3. Osserviamo che gli alberi cardinali e gli alberi ordinali sono due strutture di dati differenti, nonostante l'apparente somiglianza. Gli alberi nella Figura 4.13 sono distinti se considerati come alberi cardinali, in quanto il nodo D è il figlio destro del nodo B nel primo caso ed è il figlio sinistro nel secondo caso, mentre tali alberi sono indistinguibili come alberi ordinali in quanto D è il primo (e unico) figlio di B. Nel caso degli alberi ordinali, non conviene preallocare un nodo in modo da poter ospitare il massimo numero di figli, essendo il suo grado variabile. Usiamo quindi la memorizzazione binarizzata dell'albero, introducendo semplici nodi in cui, oltre al campo u . d a t o , sono presenti anche i campi u . p a d r e per il riferimento al padre, u . p r i m o per il riferimento al primo figlio (quello con numero 0) e u . f r a t e l l o per il riferimeno al successivo fratello nell'ordine filiare. Un esempio di memorizzazione binarizzata è mostrato nella Figura 4.14. Osserviamo che, a differenza degli alberi cardinali in cui l'accesso a un qualunque figlio richiede sempre tempo costante, negli alberi ordinali per raggiungere il figlio i (con i > 0) è necessario O(i) tempo per scandire la lista dei figli con il seguente frammento di codice: p = u.primo; j = 0; WHILE ((p != nuli) && (j < i)) { p = p.fratello; j = j+i;

>

Figura 4.14

Memorizzazione binarizzata dell'albero ordinale mostrato nella Figura 4.1. I riferimenti u . f r a t e l l o sono rappresentati come frecce tratteggiate per distinguerli dai riferimenti u . primo.

Quindi la memorizzazione binarizzata dei nodi in un albero ordinale è analoga alla rappresentazione degli alberi binari, ma la semantica delle due rappresentazioni è ben diversa! Allo stesso tempo, la memorizzazione binarizzata permette di stabilire l'esistenza di una corrispondenza biunivoca tra gli alberi binari e gli alberi ordinali: ogni albero binario di n nodi con radice r è la memorizzazione binarizzata di un distinto albero ordinale di n + 1 nodi in cui viene introdotta una nuova radice fittizia il cui primo figlio è r. Tale corrispondenza identifica il campo u . s x degli alberi binari con il campo u . p r i m o della memorizzazione binarizzata degli alberi ordinali e il il campo u . dx con il campo u . f r a t e l l o , e viene esemplificata nella parte superiore della Figura 4.15, dove la radice fittizia è mostrata come un pallino (la radice fittizia è introdotta ai soli fini della presente discussione). Un altro esempio deriva dai due alberi binari mostrati nella Figura 4.13, quando questi sono interpretati come la memorizzazione binarizzata di due distinti alberi ordinali: nel primo caso i nodi B e D sono fratelli, mentre nel secondo caso D è il primo (e unico) figlio di B. E possibile stabilire anche una corrispondenza biunivoca tra alberi ordinali e sequenze di parentesi bilanciate, come mostrato nella parte inferiore della Figura 4.15, utilizzando il Codice 4.16. La regola utilizzata è ricorsiva: ogni nodo u (di grado d) è associato a una coppia di parentesi bilanciate (• • • ) e i suoi figli sono ricorsivamente codificati ciascuno con una sequenza bilanciata di parentesi. Quindi, la codifica del sottoalbero radicato in u risulta nella sequenza di parentesi annidate ( V( • • • ) ( • • • ) • • • ( • • • ) / ) v d sottoalberi

dove la prima coppia di parentesi annidata corrisponde al primo figlio (e relativo sottoal-

ParentesiOrdinali( u ): PRINT '(';

p = u.primo; WHILE (p != nuli) {

ParentesiOrdinali( p ); p = p.fratello;

> PRINT ')'; Codice 4.16

Visita anticipata per la rappresentazione di un albero ordinale (non vuoto) mediante le parentesi bilanciate.

bero), la seconda coppia annidata corrisponde al secondo figlio (e relativo sottoalbero) e così via (Figura 4.15). Osserviamo che la sequenza di parentesi bilanciate così ottenuta codifica univocamente la struttura di un albero ordinale. Di conseguenza, vale la seguente (non ovvia) proprietà: esiste una corrispondenza biunivoca tra gli alberi binari di n nodi, gli alberi ordinali di n + 1 nodi e le sequenze bilanciate di 2 n parentesi! Quindi la cardinalità di ciascuno di questi tre insiemi è data dal numero di Catalan discusso nel Paragrafo 4.3.4.

4.4.1

Rappresentazione succinta mediante parentesi bilanciate

La corrispondenza tra alberi ordinali e parentesi bilanciate permette di utilizzare quest'ultime per una rappresentazione succinta ottima usando 2 n + o(n) bit (il limite inferiore basato sul numero di Catalan si applica anche a questa rappresentazione). Utilizzando una variante del Codice 4.16, i nodi dell'albero sono memorizzati in un array n o d o in ordine di visita anticipata e le correspondenti coppie di parentesi vengono codificate in un array binario p a r e n t e s i , dove i bit pari a 1 codificano le parentesi aperte e i bit pari a 0 codificano le parentesi chiuse. L'elemento nodo[i] è associato alla (i + l)-esima parentesi aperta. Nell'esempio della Figura 4.15, otteniamo la seguente configurazione degli array n o d o e p a r e n t e s i (in cui viene messo in evidenza l'accoppiamento delle parentesi): match

I n rr^i ni n |

• F b D B RB XY Z y PB, 1 1 1 0 1 l o o nodo

1 oo

parentesi

1 oo ,

X n 0

1 2

3 4

5 6 7

rn n

8 9 10 11 12 13

( ( ( ) (J ( ) ) ( ) ) 1 ( 1 ) 1 )

• FBDB - RbXy Figura 4.15

Zy

PB

Corrispondenza biunivoca tra un albero binario di n nodi, un albero ordinale di n + 1 nodi e una sequenza di 2n parentesi bilanciate (ignorando la coppia per la radice fittizia, rappresentata con un pallino).

Oltre alle funzioni Rank e S e l e c t necessarie a passare dagli elementi dell'array nodo ai corrispondenti bit in p a r e n t e s i e viceversa, utilizziamo la seguente funzione: • Match(b,i) = intero j tale che i e ) sono le posizioni di una coppia di parentesi bilanciate, per 0 ^ i, j ^ 2 n — 1. Se p a r e n t e s i [ l ] = 1 e p a r e n t e s i [ r ] = 0 codificano la coppia di parentesi bilanciate che rappresenta nodo [il, allora 1 = M a t c h ( p a r e n t e s i , r) e r = M a t c h ( p a r e n t e s i , l); inoltre, i = R a n k ( p a r e n t e s i , l) e l = S e l e c t ( p a r e n t e s i , i ) . L'implementazione di Match segue la falsariga di quella di Rank e S e l e c t descritta nel Paragrafo 4.3.3, utilizzando però tecniche più sofisticate. Lo spazio totale utilizzato da p a r e n t e s i e dalle implementazioni di Rank, S e l e c t e Match è pari a 2 n + o(n) bit. Tale rappresentazione succinta è quindi adatta per la struttura dei documenti XML, che possono essere propriamente modellati come alberi ordinali con nodi etichettati e che costituivano la motivazione iniziale per la progettazione di rappresentazioni succinte. Per navigare all'interno della rappresentazione succinta, il Codice 4.17 illustra come simulare i riferimenti per u = nodo[i]. Il riferimento u . p r i m o è simulato prendendo la parentesi in posizione 1 + 1 , successiva a quella aperta corrispondente a nodo[i] in posizione 1 (riga 2). Se tale parentesi è chiusa (riga 3), vuol dire che il riferimento è n u l i ; altrimenti, la parentesi aperta in posizione 1 + 1 corrisponde a n o d o [ i + 1], ovvero il primo figlio di nodo[i] (riga 6). Il riferimento u . f r a t e l l o è simulato calcolando la posizione r che contiene la parentesi chiusa della coppia corrispondente a nodo[i]

IndicePrimoFiglio( i ): 1 = Select( parentesi, i ); IF (parentesi[1 + 1] == 0) { RETURN nuli; } ELSE { RETURN I + 1;

> IndiceFratelloSuccessivo( i ): 1 = Select( parentesi, i ); r = Match( parentesi, 1 ); IF (parentesi[r + 1] == 0) { RETURN nuli; > ELSE {

RETURN Rank( parentesi, r + 1 ) - 1;

> Codice 4.17

Simulazione dei riferimenti primo e fratello per nodo[i]. Tali riferimenti, se diversi da nuli, restituiscono la posizione del corrispondente elemento nell'array nodo.

(riga 3): se la parentesi in posizione r + 1 è chiusa, vuol dire che il riferimento è n u l i ; altrimenti, essa corrisponde al fratello di nodo[i] e il numero di parentesi aperte che la precedono indica la sua posizione nell'array n o d o (riga 7). ALVIE: rappresentazione succinta con parentesi bilanciate

Osserva, sperimenta e verifica BracketRepresentation

La corrispondenza biunivoca, illustrata nella Figura 4.15, ci permette di rappresentare anche gli alberi binari, in alternativa alla rappresentazione succinta per ampiezza descritta nel Paragrafo 4.3.2. Notiamo che non possiamo rappresentare direttamente un albero binario mediante parentesi perché quest'ultime non ci permettono di distinguere se un unico figlio sia sinistro o destro (come accade nella Figura 4.13). Conviene invece utilizzare la corrispondenza con gli alberi ordinali, secondo quanto illustrato nella Figura 4.15. Notiamo che la rappresentazione succinta mediante parentesi bilanciate permette di fornire, in tempo costante, più funzionalità rispetto a quella per ampiezza, come ad esempio il calcolo della dimensione di un sottoalbero o la risposta alle query

per il problema LCA discusso nel Paragrafo 4.2. Queste funzionalità sono rese operative utilizzando sempre 2 n + o(n) bit in totale. RIEPILOGO In questo capitolo abbiamo descritto come effettuare computazioni e visite ricorsive negli alberi. Abbiamo poi mostrato una soluzione efficiente al problema del minimo antenato comune. Infine, abbiamo considerato le classi degli alberi binari, cardinali e ordinali, mostrando come rappresentarli in modo efficiente dal punto di vista dello spazio. ESERCIZI 1. Dimostrate per induzione che un albero binario completamente bilanciato di altezza h. ha 2 H — 1 nodi interni e 2 h foglie. 2. Dato un vamente, l)-esimo algoritmi

array a di n elementi, progettate un algoritmo che costruisca ricorsie in tempo 0 ( n ) , un albero binario bilanciato tale che a[i] sia l'(i + campo u . d a t o in ordine di visita anticipata. Considerate anche gli per le altre visite: simmetrica, posticipata e per ampiezza.

3. Dato un albero binario, costruite un array bidimensionale m tale che, per ogni coppia di nodi u e v, l'elemento m[u] [v] contenga il minimo antenato comune di u e v. La costruzione deve seguire lo schema ricorsivo delineato nel Codice 4.3 e deve richiedere tempo ottimo 0 ( n 2 ) (senza usare la query che richiede tempo costante, descritta nel Paragrafo 4.2.1). Osservate che durante la ricorsione nel nodo corrente u, potete individuare quali coppie di nodi hanno u come minimo antenato comune. 4. Ipotizzando che un nodo u appaia per la prima volta prima di un nodo v lungo il ciclo Euleriano di un albero binario, dimostrate che il loro antenato comune minimo è quello con profondità minima nel tratto di ciclo Euleriano che va da u a v (inclusi). 5. Dato un qualunque albero con n foglie, tale che ciascuno dei nodi interni ha due o più figli, provate per induzione che il numero di nodi interni è strettamente inferiore a n . 6. Progettate un algoritmo ricorsivo per i seguenti problemi: • stabilire se un albero binario è completo a sinistra • stabilire se un albero k-ario è completamente bilanciato • calcolare il numero di foglie discendenti dalla radice di un albero ordinale.

7. Dimostrate che l'altezza di un albero completo a sinistra di n nodi è pari a h. = O(logn), utilizzando la relazione tra l'altezza e la posizione (nell'array) dei nodi incontrati partendo dalla foglia più a sinistra e risalendo gli antenati fino alla radice. 8. Dimostrate per induzione la regola adottata nella rappresentazione implicita per associare le posizioni dell'array ai riferimenti al padre e ai due figli e descritta nel Paragrafo 4.3.1. 9. Analogamente al Codice 4.14, descrivete come simulare i riferimenti al padre e ai figli usando la rappresentazione degli alberi binari mediante parentesi bilanciate (come nella corrispondenza biunivoca nella Figura 4.15). 10. Utilizzando un array simile a quello mostrato nella Figura 4.12, mostrate come implementare l'algoritmo per il minimo antenato comune utilizzando soltanto O(n) celle di memoria invece che O ( n l o g n ) (osservate che le profondità dei nodi memorizzate differiscono di uno).

Capitolo 5

Dizionari

SOMMARIO In questo capitolo descriviamo la struttura di dati denominata dizionario e le operazioni da essa fornite. Mostriamo quindi come realizzare un dizionario utilizzando le liste doppie, le tabelle hash, gli alberi di ricerca, gli alberi AVL, i B-alberi e, infine, i trie o alberi digitali di ricerca, inclusi gli alberi dei suffissi e le liste invertite. DIFFICOLTÀ 2 CFU.

5.1

Dizionari

Un dizionario memorizza una collezione di elementi e ne fornisce le operazioni di ricerca, inserimento e cancellazione. I dizionari trovano impiego in moltissime applicazioni: insieme agli algoritmi di ordinamento, costituiscono le componenti fondamentali per la progettazione di algoritmi efficienti. Ai fini della discussione, ipotizziamo che ciascuno degli elementi e contenga una chiave di ricerca, indicata con e . c h i a v e , e che il resto delle informazioni in e siano considerate dei dati satellite, indicati con e . s a t : come al solito, indicheremo l'elemento vuoto con n u l i . Definito il dominio o universo U delle chiavi di ricerca contenute negli elementi, un dizionario memorizza un insieme S = { e o , e i , . . . , e n _ i ) di elementi, dove n è la dimensione di S, e fornisce le seguenti operazioni per una qualunque chiave k e U: • R i c e r c a ( S , k): restituisce l'elemento e se k = e . c h i a v e , oppure il valore n u l i se nessun elemento in S ha k come chiave; • I n s e r i s c i ( S , e ) : estende l'insieme degli elementi ponendo S = S U {e}, con l'ipotesi che e . c h i a v e sia una chiave distinta da quelle degli altri elementi in S (se e appartiene già a S, l'insieme non cambia);

• C a n c e l l a ( S , k): elimina dall'insieme l'elemento e tale che k = e . c h i a v e e pone S = S — {e} (se nessun elemento di S ha chiave k, l'insieme non cambia). Poiché in diverse applicazioni il campo satellite e . s a t degli elementi è sempre vuoto e il dizionario memorizza soltanto l'insieme delle chiavi di ricerca distinte, l'operazione di ricerca diventa semplicemente quella di appartenenza all'insieme: • A p p a r t i e n e ( S , k): restituisce t r u e se e solo se k appartiene all'insieme S, ovvero R i c e r c a ( S , k) / n u l i . Il dizionario è detto statico se fornisce soltanto l'operazione di ricerca ( R i c e r c a ) e viene detto dinamico se fornisce anche le operazioni di inserimento ( I n s e r i s c i ) e di cancellazione ( C a n c e l l a ) . Quando una relazione di ordine totale è definita sulle chiavi dell'universo U (ovvero, per ogni coppia di chiavi k e k' G U è sempre possibile verificare se vale k < k'), il dizionario è detto ordinato: con un piccolo abuso di notazione, estendiamo gli operatori di confronto tra chiavi di ricerca ai rispettivi elementi, per cui possiamo scrivere che gli elementi di S soddisfano la relazione eo < e\ < • < en_i (intendendo che le loro chiavi la soddisfano) e che, per esempio, vale k ^ et (intendendo k ^ e^.chiave). II dizionario ordinato per S fornisce le seguenti ulteriori operazioni: • S u c c e s s o r e ( S , k): restituisce l'elemento et tale che i è il minimo intero per cui k ^ e i e 0 ^ i < n , oppure il valore n u l i se k è maggiore di tutte le chiavi in S; • P r e d e c e s s o r e ( S , k): restituisce l'elemento ei tale che i è il massimo intero per cui e i ^ k e 0 ^ i < n , oppure n u l i se k è minore di tutte le chiavi in S; • I n t e r v a l l o f S , k, k'): restituisce tutti gli elementi e € S tali che k ^ e ^ k', dove supponiamo k ^ k', oppure n u l i se tali elementi non esistono in S; • Rango(S, k): restituisce l'intero r che rappresenta il numero di chiavi in S che sono minori oppure uguali a k, dove 0 < r < n . Da notare che le prime due operazioni restituiscono lo stesso valore di R i c e r c a ( S , k ) quando k e S, mentre la terza lo ottiene come caso speciale quando k = k'. Infine, la quarta operazione può simulare le prime tre se, dato un rango r, possiamo accedere all'elemento e r G S in modo efficiente.

5.2

Liste e dizionari

Le liste doppie (Paragrafo 3.1.2) sono un ottimo punto di partenza per l'implementazione efficiente dei dizionari. Nel seguito presumiamo che una lista doppia L abbia tre campi, ovvero due riferimenti L. i n i z i o e L . f i n e all'inizio e alla fine della lista e, inoltre, un intero L. l u n g h e z z a contenente il numero di nodi nella lista. Utilizziamo una funzione N u o v a L i s t a per inizializzare i primi due campi a n u l i e il terzo a 0. Ricordiamo che ogni nodo p della lista L è composto da tre campi p . p r e d , p . s u c c e p . d a t o , e faremo uso della funzione NuovoNodo per creare un nuovo nodo quando sia necessario farlo. Il campo p . d a t o contiene un elemento e G S: quindi possiamo

InserisciCima(lista, e): p = NuovoNodo( ); p.dato = e; lun = lista.lunghezza; IF (lun == 0) { p.succ = p.pred = nuli; lista.inizio = p; lista.fine = p; > ELSE {

InserisciFondo(lista, e): p = NuovoNodo( ); p.dato = e; lun = lista.lunghezza; IF (lun == 0) { p.succ = p.pred = nuli; lista.inizio = p; lista.fine = p; > ELSE {

p.succ = lista.inizio ; p.pred = nuli; lista.inizio.pred = p; lista.inizio = p;

>

p.succ = nuli; p.pred = lista.fine; lista.fine.succ = p; lista.fine = p;

>

lista.lunghezza = lun + 1;

lista.lunghezza = lun + 1;

RETURN lista;

RETURN lista;

Codice 5.1

Inserimento in cima e in fondo a

lista doppia, componente dì un dizionario.

indicare con p . d a t o . c h i a v e e p . d a t o . s a t i campi dell'elemento memorizzato nel nodo corrente. L'uso diretto delle liste doppie per implementare i dizionari non è consigliabile per insiemi di grandi dimensioni, in quanto le operazioni richiederebbero O(n) tempo: le liste sono però una componente fondamentale di molte strutture di dati efficienti per i dizionari, per cui riportiamo il codice delle funzioni definite su di esse che saranno utilizzate nel seguito. In particolare, nel Codice 5.1, il ruolo dell'operazione I n s e r i s c i del dizionario è svolto dalle due operazioni di inserimento in cima e in fondo alla lista, per poterne sfruttare le potenzialità nei dizionari che discuteremo più avanti. Per lo stesso motivo, nel Codice 5.2, l'operazione R i c e r c a restituisce il puntatore p al nodo contenente l'elemento trovato (basta prendere p . d a t o per soddisfare le specifiche dei dizionari date nel Paragrafo 5.1). Osserviamo che le operazioni suddette implementano la gestione delle liste doppie discussa nel Paragrafo 3.1.2. Quindi, la complessità delle operazioni di inserimento riportate nel Codice 5.1 è costante indipendentemente dalla lunghezza della lista, mentre le operazioni di ricerca e cancellazione riportate nel Codice 5.2 richiedono O(n) tempo dove n è la lunghezza della lista (anche se la cancellazione effettiva richiede 0 ( 1 ) avendo il riferimento al nodo, non utilizzeremo mai questa possibilità). Un esempio di dizionario dinamico e ordinato, che abbiamo già incontrato e che si basa sulle liste, è dato dalle liste randomizzate descritte nel Paragrafo 3.3, le cui operazioni richiedono un tempo atteso di O(logn). Nel seguito descriviamo altri dizionari

Ricercai lista, k ): p = lista.inizio; WHILE ((p != nuli) && (p.dato.chiave != k)) p = p.succ; RETURN P;

Cancellai lista, k ): p = Ricercai lista, k ); IF (p != nuli) { IF (lista.lunghezza == 1) { lista.inizio = lista.fine = nuli; > ELSE IF (p.pred == nuli) { p.succ.pred = nuli; lista.inizio = p.succ; )• ELSE IF (p.succ == nuli) { p.pred.succ = nuli; lista.fine = p.pred; > ELSE {

p.succ.pred = p.pred; p.pred.succ = p.succ;

> lista.lunghezza = lista.lunghezza - 1;

> RETURN lista; Codice 5.2

Ricerca e cancellazione in una lista doppia, componente di un dizionario.

di uso comune in applicazioni informatiche: notiamo che le operazioni che gestiscono tali dizionari possono essere estese per permettere la memorizzazione di chiavi multiple, ossia la gestione di un multi-insieme di chiavi.

5.3

Opus libri: funzioni hash e peer-to-peer

Il termine inglese hash indica un polpettone ottenuto tritando della carne insieme a della vetdura, dando luogo a un composto di volume ridotto i cui ingredienti iniziali sono mescolati e amalgamati. Tale descrizione ben illustra quanto succede nelle funzioni Hash : U > [0,m — 1], aventi l'universo li delle chiavi come dominio e l'intervallo di interi da 0 a m — 1 come codominio (di solito, m è molto piccolo se confrontato con la dimensione di U): una funzione Hash(k) = h. trita la chiave k € li restituendo come risultato un intero 0 ^

h. ^ m — 1. Notiamo che tale funzione non necessariamente preserva l'ordine delle chiavi appartenenti all'universo LI. Alcune funzioni hash sono semplici e utilizzano la codifica binaria delle chiavi (per cui, nel seguito, identifichiamo una chiave k con la sua codifica in binario): • Hash(k) = k % m calcola il modulo di k utilizzando un numero primo m; • Hash(k) = ko © k] © • • •ffik s _ i spezza la codifica binaria di k nei blocchi ko, k j , . . . , k s „ i di pari lunghezza, dove 0 < ki < m — l e l'operazione © indica l'OR esclusivo.1 La seconda funzione hash è chiamata iterativa in quanto divide la chiave k in blocchi di sequenze binarie ko, k[, . . . , k s i e lavora su tali blocchi, di fatto ripiegando la chiave su se stessa (i blocchi hanno la stessa lunghezza e alla chiave vengono aggiunti dei bit in fondo se necessario). Altre funzioni hash sono più sofisticate, per esempio quelle nate in ambito crittografico come M D 5 {Message-Digest Algorithm versione 5), inventata dal crittografo Ronald Rivest ideatore del metodo RSA, e SHA-1 (Secure Hash Algorithm versione 1), introdotta dalla National Security Agency del governo statunitense. Queste funzioni sono iterative e lavorano su blocchi di 512 bit applicandovi un'opportuna sequenza di operazioni logiche per manipolare i bit (per esempio, l'OR esclusivo o la rotazione dei bit) restituendo cosi un intero a 128 bit (MD5) O a 160 bit (SHA-1). Ad esempio, la valutazione di M D 5 ( a l g o r i t m o ) con la chiave " a l g o r i t m o " restituisce la sequenza esadecimale 2 446cead90f929el03816ff4eb92da6c2 mentre SHA-1 (algoritmo) restituisce 6f77f39f5ea82a55df8aaf4f094e2ff0e26d2adb La caratteristica di queste funzioni hash è che, cambiando anche leggermente la chiave, l'intero risultante è completamente diverso. Ad esempio, M D 5 ( a l g o r i t m i ) restituisce 6a8af95d7f185bla223c5b20cc71eb4a mentre SHA-1 (algoritmi) restituisce 147d401a6ale3c20e7d6796bcac50a993726d4fa Volendo ottenere un valore hash nell'intervallo [0,m — 1] (dove m è molto minore di 2 1 2 8 ), possiamo utilizzare tali funzioni nel modo seguente. •

Hash(k) = MD5(k) % m

• Hash(k) = SHA-1 ( k ) % m Osserviamo che, essendo la dimensione dell'universo U molto vasta, esistono sempre due chiavi ko e k] in U tali che ko ^ k j e Hash(ko) = Hash(k] ): una tale situazione è 'L'OR esclusivo tra due bit vale 1 se e solo se i due bit sono diversi (0 e 1, oppure 1 e 0): la notazione Q © b = c indica l'OR esclusivo bitwise, in cui il bit i-esimo di c è l'OR esclusivo del bit i-esimo di a e b. 2 La codifica esadecimale usa sedici cifre 0, 1, ..., 9, a, b f per codificare 24 possibili configurazioni di 4 bit.

chiamata collisione. Tuttavia, la natura deterministica del calcolo delle suddette funzioni hash, fa si che se Hash(ko) ^ Hash(ki) allora ko ^ k ( . Questa proprietà tipica delle funzioni in generale, coniugata con la robustezza di M D 5 e SHA-1 in ambito crittografico (soprattutto la versione più recente SHA-2 che restituisce un intero a 512 bit), trova applicazione anche nei sistemi distribuiti di condivisione dei file (peer-to-peer). In tali sistemi distribuiti (come BitTorrent, FreeNet, Gnutella, E-Mule, Napster e così via), l'informazione è condivisa e distribuita tra tutti i client o peer piuttosto che concentrata in pochi server, con un enorme vantaggio in termini di banda passante e tolleranza ai guasti della rete: la partecipazione è su base volontaria e, al momento di scaricare un determinato file, i suoi blocchi sono recuperati da vari punti della rete. Un numero sempre crescente di servizi operanti in ambiente distribuito usufruisce dei protocolli creati per tali sistemi (ad esempio, la telefonia via Internet). In tale scenario, lo stesso file può apparire con nomi diversi o file diversi possono apparire con lo stesso nome. Essendo la dimensione di ciascun file dell'ordine di svariati megabyte, quando i peer devono verificare quali file hanno in comune, è impensabile che questi si scambino direttamente il contenuto dei file: in tal modo, tutti i peer riceverebbero molti file da diversi altri peer e questo è impraticabile per la grande quantità di dati coinvolti. Prendiamo per esempio il caso di due peer P e P' che vogliano capire quali file hanno in comune. Non potendo affidarsi ai nomi dei file devono verificarne il contenuto e l'uso delle funzioni hash in tale contesto è formidabile: per ogni file f memorizzato, P calcola il valore SHA-1 (f ), chiamato impronta digitale {digitaifingerprint), spedendolo a P' (solo 160 bit) al posto di f (svariati megabyte). Da parte sua, P' riceve tali impronte digitali da P e calcola quelle dei propri file. Dal confronto delle impronte può dedurre con certezza quali file sono diversi e, con altissima probabilità, quali file sono uguali. Un altro uso dell'hash in tale scenario è quando P decide di scaricare un file f. Tale file è distribuito nella rete e, a tale scopo, è stato diviso in blocchi f o , f i , . . . , f s - i : oltre all'impronta h. = SHA-l(f) dell'intero file, sono disponibili anche le impronte hi = SHA-1 (fi) dei singoli blocchi (per 0 ^ i ^ s — 1). A questo punto, dopo aver recuperato le sole impronte digitali h, ho, h i , . . . , h s ^ i attraverso un'opportuna interrogazione, P lancia le richieste agli altri peer diffondendo tali impronte. Appena ha terminato di ricevere i rispettivi blocchi fi in modo distribuito, P ricostruisce f da tali blocchi e verifica che le impronte digitali corrispondano: la probabilità di commettere un errore con tali funzioni hash è estremamente basso. Viste le loro proprietà, è naturale utilizzare le funzioni hash per realizzare un dizionario che memorizzi un insieme S = {eo, e i , . . . , e n _ | } C U di elementi. I dizionari basati sull'hash sono noti come tabelle hash (hash map) e sono utili per implementare una struttura di dati chiamata array associativo, i cui elementi sono indirizzati utilizzando le chiavi in S piuttosto che gli indici in [0, n — 1].

La situazione ideale si presenta quando, fissando m = O(n), la funzione Hash. è perfetta su S, ovvero nessuna coppia di chiavi in S genera una collisione: in tal caso, il dizionario è realizzato mediante un semplice array binario t a b e l l a di m bit inizialmente uguali a 0, in cui ne vengono posti n pari a 1 con la regola che t a b e l l a [ h ] = 1 se e solo se h. = Hash(ei. c h i a v e ) per ciascun elemento e^ dove 0 ^ i < n — 1. Essendo una funzione perfetta, Hash non necessita di ulteriori controlli: tuttavia, inserendo o cancellando elementi in S, può accadere che Hash facilmente perda la proprietà di essere perfetta su S. Da notare che esistono dizionari dinamici basati su famiglie di hash che richiedono 0(1) tempo al caso pessimo per la ricerca e O ( 1 ) tempo medio ammortizzato per l'inserimento e la cancellazione. Il limite di 0 ( 1) tempo per la ricerca non è in contrasto con quello di O(logn) confronti per la ricerca (Paragrafo 2.4.2): infatti, nel primo caso i bit della chiave k vengono manipolati da una o più funzioni hash per ottenere un indice dell'array t a b e l l a mentre nel secondo caso k viene soltanto confrontata dalla ricerca binaria con le altre chiavi. In altre parole, il limite di n ( l o g n ) confronti vale supponendo che l'unica operazione permessa sulle chiavi sia il loro confronto diretto con altre (oltre alla loro memorizzazione), mentre tale limite non vale se i bit delle chiavi possono essere usati per calcolare una funzione diversa dal confronto di chiavi. La costruzione dei suddetti dizionari dinamici basati sull'hash perfetto è piuttosto macchinosa e le loro prestazioni in pratica non sono sempre migliori dei dizionari che fanno uso di funzioni hash non necessariamente perfette. Questi ultimi, pur richiedendo per la ricerca 0(1) tempo in media invece che al caso pessimo, sono ampiamente diffusi per la loro efficienza in pratica e per la semplicità della loro gestione, che si riduce a risolvere le collisioni prodotte dalle chiavi. Nel seguito descriveremo due semplici modi per fare ciò: mediante liste di trabocco (che oltretutto garantiscono 0(1) tempo al caso pessimo per inserire una chiave non presente in S) oppure con l'indirizzamento aperto.

5.3.1

Tabelle hash: liste di trabocco

Nelle tabelle hash con liste di trabocco (chaining), t a b e l l a è un array di m liste doppie, gestite secondo quanto descritto nel Paragrafo 5.2, e t a b e l l a [ h ] contiene le chiavi e dell'insieme S tali che h. = H a s h ( e . c h i a v e ) : in altre parole, le chiavi che collidono fornendo lo stesso valore h. di Hash sono memorizzate nella medesima lista, etichettata con h. (ovviamente tale lista è vuota se nessuna chiave dà luogo a un valore hash h). L'operazione di ricerca scandisce la lista associata al valore hash della chiave, mentre l'operazione d'inserimento, dopo aver verificato che la chiave dell'elemento non appare nella lista, inserisce un nuovo nodo con tale elemento in fondo alla lista. La cancellazione verifica che la chiave sia presente e rimuove il corrispondente elemento, e quindi il nodo, dalla lista doppia corrispondente.

Ricerca( tabella, k ) : h = Hash(k); p = tabella[h].Ricerca( k ); IF (p != nuli) RETURN p.dato ELSE RETURN nuli;

' Inserisci( tabella, e ): IF (Ricercai tabella, e.chiave ) == nuli) { h = Hash( e.chiave ); tabella[h].InserisciFondo( e );

> Cancellai tabella, k ): IF (Ricercai tabella, k ) != nuli) { h = Hash(k); tabella[h].Cancella( k );

> Codice 5.3

Dizionario realizzato mediante tabelle hash con liste di trabocco.

Pur avendo un caso pessimo di 0 ( n ) tempo (tutte le chiavi danno luogo allo stesso valore hash), ciascuna operazione è molto veloce in pratica se la funzione hash scelta è buona: in effetti, il costo medio è 0 ( 1 ) tempo con l'ipotesi che la funzione Hash distribuisca in modo uniformemente casuale gli n elementi di S nelle m liste di trabocco. In questo modo, la lunghezza media di una qualunque delle liste è 0 ( ^ ), dove ^ = a è chiamato fattore di caricamento: quindi, le operazioni sulla tabella richiedono in media un tempo costante 0 ( 1 + a) perché il loro costo è proporzionale alla lunghezza della lista acceduta. Mantenendo l'invariante che m è circa il doppio di n (Paragrafo 2.1.3), abbiamo che a = 0 ( 1 ) e il costo delle operazioni diventa costante. ALVIE: gestione di tabelle hash con liste di trabocco

Jh^j^

5.3.2

Osserva, sperimenta e verifica ChainingHash

Tabelle hash: indirizzamento aperto

Nelle tabelle hash a indirizzamento aperto (open addressing), t a b e l l a è un array di m celle in cui porre gli n elementi, dove m > n (quindi a < 1), in cui usiamo n u l i

Ricerca( tabella, k ): FOR (i = 0; i < M; i = i+1) { h = Hash[i](k); IF (tabella[H] == null) RETURN -1;

IF (tabella[h].chiave == k) RETURN tabella[h];

> Inserisci ( tabella, e ): {pre: tabella contiene ri < m chiavi) IF (Ricercai tabella, e.chiave ) == nuli) { i = -1; DO {

i = i+1; h = Hash[i]( e.chiave ); IF (tabella[h] == nuli) tabella[h] = e; > WHILE (tabella[h]

Codice 5.4

!= e);

Dizionario realizzato mediante tabelle hash con indirizzamento aperto.

per segnalare che la posizione corrente è vuota. Poiché le chiavi sono tutte collocate direttamente nell'array, usiamo una sequenza di funzioni Hash[i] per 0 ^ i < m — 1, chiamata sequenza di scansione {probing), tali che i valori Hash[0](k), Hash[l](k), . . . , Hash[m — l](k) formano sempre una permutazione delle posizioni 0 , 1 , . . . , m — 1, per ogni chiave k € U. Tale permutazione rappresenta l'ordine con cui esaminiamo le posizioni di t a b e l l a durante le operazioni del dizionario. Per comprendere l'organizzazione delle chiavi nella tabella hash, descriviamo prima l'operazione di inserimento di un elemento. Il Codice 5.4 mostra tale operazione, in cui iniziamo a esaminare le posizioni Hash[0](k), Hash[l](k), . . . , Hash[m — l](k) fino a trovare la prima posizione Hash[i](k) libera (poiché n < m, siamo sicuri che i < m): tale procedimento è analogo a quando cerchiamo posto in treno, in cui andiamo avanti fino a trovare un posto libero (ovviamente esaminiamo i posti in ordine lineare piuttosto che permutato). La ricerca di una chiave k segue questa falsariga: esaminiamo le suddette posizioni fino a trovare l'elemento con chiave k e, nel caso giungiamo in una posizione libera, siamo certi che la chiave non compare nella t a b e l l a (altrimenti l'inserimento avrebbe posto in tale posizione libera un elemento con chiave k). La cancellazione di una chiave è solitamente realizzata in modo virtuale, sostituendo l'elemento con una marca speciale, che indica che la posizione è libera durante l'operazione d'inserimento di successive chiavi e che la posizione è occupata ma con una chiave diversa da quella cercata durante le successive operazioni di ricerca: quest'ultima condizione è necessaria poiché una cancellazione che svuotasse la posizione della chiave rimossa, potrebbe ingannare

una successiva ricerca (non necessariamente della stessa chiave) inducendola a fermarsi erroneamente in quella posizione e dichiarare che la chiave cercata non è nel dizionario. Se prevediamo di effettuare molte cancellazioni, è quindi più conveniente usare una tabella con liste di trabocco perché si adatta meglio a realizzare dizionari molto dinamici. Per la complessità temporale, osserviamo che il caso pessimo rimane O(n) tempo e che ciascuna operazione è molto veloce in pratica se la funzione hash scelta è buona: in effetti, il costo medio è 0 ( 1 ) tempo con l'ipotesi che, per ogni chiave k, le posizioni in Hash[0](k), Hash[l](k), . . . , Hash[m — l](k) formino una delle m! permutazioni possibili in modo uniformemente casuale. Poiché il costo è direttamente proporzionale al valore di i tale che Hash[i](k) è la posizione individuata per la chiave, indichiamo con T(n, m) il valore medio di i: in altre parole, T(n, m) indica il numero medio di posizioni che troviamo occupate quando inseriamo un'ulteriore chiave in una tabella di m posizioni, contenente n elementi, dove n < m. Utilizziamo un'equazione di ricorrenza per definire T ( n , m ) , dove T(0,m) = 1 in quanto ogni posizione esaminata è sempre libera in una tabella vuota. Per n > 0, osserviamo che, essendo occupate n posizioni su m della tabella, la posizione esaminata risulta occupata n volte su m (poiché tutte le permutazioni di posizioni sono equiprobabili): in tal caso, effettuiamo un solo accesso e ci fermiano su una posizione libera con probabilità -n3^I1> mentre, con probabilità troviamo la posizione occupata per cui effettuiamo ulteriori T(n — l , m — 1) accessi alle rimanenti posizioni (oltre all'accesso alla posizione occupata). Facendo la media pesata di tali costi (abbiamo già incontrato un'analisi al caso medio di questo tipo nei Paragrafi 2.5.4 e 3.3), otteniamo x l + ^ x (1 + T ( n - l , m - 1)), dando luogo alla seguente equazione di ricorrenza:

T(n,m) = |

| ^ i j ( n - l , m — 1)

linimenti

(5>1)

Proviamo per induzione che la soluzione della (5.1) soddisfa la relazione T(n, m) ^ ™ • Il caso base per n = 0 e m > O è immediato, mentre, per n > 0 e m > n, abbiamo che T ( n , m = 1 -I

m

T u - l,m- 1 < 1H

x m m

= — n m - n

Ne consegue che T(n, m) ^ = (1 — a ) - 1 = 0 ( 1 ) mantenendo l'invariante che m sia circa il doppio di n (Paragrafo 2.1.3). Da notare che i tempi medi calcolati per le tabelle hash con liste di trabocco e a indirizzamento aperto non sono direttamente confrontabili in quanto l'ipotesi di uniformità della funzione hash nel secondo caso è più forte di quella adottata nel primo caso. Nella pratica, non possiamo generare una permutazione veramente casuale delle posizioni scandite con Hash[i] per 0 ^ i < m — 1. Per questo motivo, adottiamo alcune

semplificazioni usando una o due funzioni Hash(k) e H a s h ' ( k ) (come quelle descritte nel Paragrafo 5.3), impiegandole come base di partenza per le scansioni della tabella, la cui dimensione m è un numero primo, in uno dei modi seguenti: • Hash[i](k) = (Hash(k) + i) % m (scansione lineare); • Hash[i](k) = (Hash(k) + ai2 + bi + c) % m (scansione quadratica); • Hash[i](k) = (Hash(k) + i x (1 + Hash'(k))) % m (scansione basata su hash doppio). Nella scansione lineare, dopo aver calcolato il valore h = Hash(k), esaminiamo le posizioni H, h.+1, h + 2 e così via in modo circolare. Tale scansione crea delle aggregazioni (,cluster) di elementi, che occupano un segmento di posizioni contigue in t a b e l l a . Tali elementi sono stati originati da valori hash h. differenti, ma condividono lo stesso cluster: la ricerca che ricade all'interno di tale cluster deve percorrerlo tutto nel caso non trovi la chiave. Un più attento esame delle chiavi contenute nel cluster mostra che quelle che andrebbero a finire in una stessa lista di trabocco (Paragrafo 5.3.1) sono tutte presenti nello stesso cluster (e tale proprietà può valere per più liste, le cui chiavi possono condividere lo stesso cluster). Pertanto, quando tali cluster sono di dimensione rilevante (seppure costante), conviene adottare le tabelle hash con liste di trabocco che hanno prestazioni migliori, quando sono associate a una buona funzione hash. La scansione quadratica non migliora molto la situazione, in quanto i cluster appaiono in altra forma, seguendo l'ordine specificato da Hash[i](k). La situazione cambia usando il doppio hash, in quanto l'incremento della posizione esaminata in t a b e l l a dipende da una seconda funzione H a s h ' : se due chiavi hanno una collisione sulla prima funzione hash, c'è ancora un'ulteriore possibilità di evitare collisioni con la seconda. ALVIE:

gestione di tabelle hash con indirizzamento aperto

Osserva, sperimenta e verifica OpenHash

5.4

Opus libri: kernel Linux e alberi binari di ricerca

Nel sistema operativo GNU/Linux, la gestione dei processi generati dai vari programmi in esecuzione è prevista nel suo nucleo {kernel). In particolare, ogni processo ha a disposizione uno spazio virtuale degli indirizzi di memoria, detta memoria virtuale, in cui le celle sono numerate a partire da 0. La memoria virtuale fa sì che il calcolatore (utilizzando la memoria secondaria) sembri avere più memoria principale di quella fisicamente

presente, condividendo quest'ultima tra tutti i processi che competono per il suo uso. La memoria virtuale di un processo è suddivisa in aree di memoria (VMA) di dimensione limitata, ma solo un sottoinsieme di tutte le VMA associate a un processo risultano presenti fisicamente nella memoria principale. Quando un processo accede a un indirizzo di memoria virtuale, il kernel deve verificare che la VMA contenente quell'indirizzo sia presente in memoria principale: se è così, usa le informazioni associate alla VMA per effettuare la traduzione dell'indirizzo virtuale nel corrispondente indirizzo fisico. In caso contrario, si verifica un page fault che costringe il kernel a caricare in memoria principale la VMA richiesta, eventualmente scaricando in memoria secondaria un'altra VMA (scelta, ad esempio, applicando la politica LRU discussa nel Paragrafo 3.4.2). La ricerca della VMA deve essere eseguita in modo efficiente: a tale scopo, il kernel usa una strategia mista (tipica di Linux e applicata anche in altri contesti del sistema operativo), che è basata sull'uso di dizionari. Fintanto che il numero di VMA presenti in memoria è limitato (circa una decina), le VMA assegnate a un processo sono mantenute in una lista e la ricerca di una specifica VMA viene eseguita attraverso di essa. Quando il numero di VMA supera un limite prefissato, la lista viene affiancata da una struttura di dati più efficiente dal punto di vista della ricerca: tale struttura di dati è chiamata albero binario di ricerca (fino alla versione 2.2 del kernel, venivano usati gli alberi AVL, mentre nelle versioni successive questi sono stati sostituiti dagli alberi rosso-neri). In effetti, gli alberi binari di ricerca costituiscono uno degli strumenti fondamentali per il recupero efficiente di informazioni e sono pertanto applicati in moltissimi altri contesti, oltre a quello appena discusso.

5.4.1

Alberi binari di ricerca

Un albero binario viene generalmente rappresentato nella memoria del calcolatore facendo uso di tre campi, come mostrato nel Capitolo 4: dato un nodo u, indichiamo con u . s x il riferimento al figlio sinistro, con u . dx il riferimento al figlio destro e con u . d a t o il contenuto del nodo, ovvero un elemento e e S nel caso di dizionari (precisamente, faremo riferimento a u . d a t o . c h i a v e e u . d a t o . s a t per indicare la chiave e i dati satellite di tale elemento). Volendo impiegare gli alberi per realizzare un dizionario ordinato per un insieme S = (eo, e j , . . . , e n _ i } di elementi, memorizziamo gli elementi nei loro nodi in modo da soddisfare la seguente proprietà di ricerca per ogni nodo u: • tutti gli elementi nel sottoalbero sinistro di u (riferito da u . sx) sono minori dell'elemento u . d a t o contenuto in u; • tutti gli elementi nel sottoalbero destro di u (riferito da u . dx) sono maggiori di u.dato. Un albero binario di ricerca è un albero binario che soddisfa la suddetta proprietà di ricerca: una conseguenza della proprietà è che una visita simmetrica dell'albero fornisce la sequenza ordinata degli elementi in S, in tempo O(n).

Ricercai u, k ): IF (u == null) RETURN nuli;

IF (k == u.dato.chiave) { RETURN u.dato; > ELSE IF (k < u.dato.chiave) { RETURN Ricercai u.sx, k ); > ELSE { RETURN Ricercai u.dx, k );

> Inserisci( u, e ) : IF iu == nuli) { u = NuovoNodoi); u.dato = e; u.sx = u.dx = nuli ; } ELSE IF ie.chiave < u.dato.chiave) {

u.sx = Inserisci( u.sx, e ); > ELSE IF (e.chiave > u.dato.chiave) {

u.dx = Inserisci( u.dx, e );

> RETURN U; C o d i c e 5.5

{post: se k appare già in u, non viene memorizzata)

Algoritmi ricorsivi per la ricerca dell'elemento con chiave k e l'inserimento di un elemento e in un albero di ricerca con radice u.

La ricerca di una chiave k in tale albero segue la falsariga della versione ricorsiva della ricerca binaria (Paragrafo 2.5). Il Codice 5.5 ricalca tale schema ricorsivo: partiamo dalla radice dell'albero e confrontiamo il suo contenuto con k e, nel caso sia diverso, se k è minore proseguiamo la ricerca a sinistra, altrimenti la proseguiamo a destra. Per l'inserimento osserviamo che, quando raggiungiamo un riferimento vuoto, lo sostituiamo con un riferimento a un nuovo nodo (righe 3—5), che restituiamo per farlo propagare verso l'alto (riga 11) attraverso le chiamate ricorsive (abbiamo discusso tali schemi ricorsivi nel Paragrafo 4.1.1): tale propagazione avviene notando che le chiamate ricorsive alle righe 7 e 9 sovrascrivono il campo relativo al riferimento (figlio sinistro o destro) su cui sono state invocate. Infatti se k è minore della chiave nel nodo corrente, l'inseriamo ricorsivamente nel figlio sinistro; se k è maggiore, l'inseriamo ricorsivamente nel figlio destro; altrimenti, abbiamo un duplicato e non l'inseriamo affatto. Il costo della ricerca e dell'inserimento è pari all'altezza h dell'albero, ovvero 0(h.) tempo. La cancellazione dell'elemento con chiave k presenta più casi da esaminare, in quanto essa può disconnettere l'albero che va, in tal caso, opportunamente riconnesso per mantenere la proprietà di ricerca, come descritto nel Codice 5.6, il cui schema ricorsivo

Cancellai u, k ): IF (u != nuli) { IF (u.dato.chiave == k) { IF (u.sx == nuli) { u = u.dx; } ELSE IF (u.dx == nuli) {

u = u.sx; > ELSE {

w = MinimoSottoAlbero( u.dx ); u.dato = w.dato; u.dx = Cancella( u.dx, w.dato.chiave );

> > ELSE IF (k < u.dato.chiave) {

u.sx = Cancellai u.sx, k ); > ELSE IF (k > u.dato.chiave) {

u.dx = Cancellai u.dx, k );

> > RETURN u;

MinimoSottoAlbero( u ):

{pre: u / nuli)

WHILE (u.sx != nuli)

u = u.sx; RETURN u; Codice 5.6

Algoritmo ricorsivo per la cancellazione dell'elemento con chiave k da un albero di ricerca con radice u.

è simile a quello dell'inserimento. I casi più semplici sono quando il nodo u è una foglia oppure ha un solo figlio (righe 5 e 7): eliminiamo la foglia mettendo a n u l i il riferimento a essa oppure, se il nodo ha un solo figlio, creiamo un "ponte" tra il padre di u e il figlio di liQuando u. ha due figli non possiamo cancellarlo fisicamente (righe 9-11), ma dobbiamo individuare il nodo w che contiene il successore di k nell'albero (riga 9), che risulta essere il minimo del sottoalbero destro ( u . d x non è n u l i ) . Sostituiamo quindi l'elemento in u. con quello in w per mantenere la proprietà di ricerca dell'albero (riga 10) e, con una chiamata ricorsiva, cancelliamo fisicamente w in quanto contiene la chiave copiata in u. (riga 11). E importante osservare che quest'ultima s'imbatterà in un caso semplice con la cancellazione di w, in quanto w non può avere il figlio sinistro (altrimenti non conterrebbe il minimo del sottoalbero destro). C o m e osservato in precedenza, propaghiamo l'effetto

della cancellazione verso l'alto (riga 19) attraverso le chiamate ricorsive. Per la complessità temporale, osserviamo che il codice percorre il cammino dalla radice al nodo u in cui si trova l'elemento con chiave k e poi percorre due volte il cammino da u al suo discendente w. In totale, il costo rimane 0(h.) tempo anche in questo caso. Purtroppo h = Q ( n ) al caso pessimo e un albero non sembra essere vantaggioso rispetto a una lista ordinata. Tuttavia, con elementi inseriti in maniera casuale, l'altezza media è O(logn) e i metodi discussi finora hanno una complessità O(logn) al caso medio. Vediamo come ottenere degli alberi binari di ricerca bilanciati, che hanno sempre altezza H = O(logn) dopo qualunque inserimento o cancellazione. Questo fa sì che la complessità delle operazioni diventi O(logn) anche al caso pessimo. A L V I E:

ricerca, inserimento e cancellazione in alberi di ricerca

^ R y ' fi W jSSB^ Osserva, sperimenta e verifica BinarySearchTree

5.4.2

©

©

©

©

© ©© © % ©

AVL: alberi binari di ricerca bilanciati

L'albero AVL (acronimo derivato dalle iniziali degli autori russi Adel'son-Velsky e Landis che lo inventarono negli anni '60) è un albero binario di ricerca che garantisce avere un'altezza h. = O(logn) per n elementi memorizzati nei suoi nodi. Oltre alla proprietà di ricerca menzionata nel Paragrafo 5.4.1, l'albero AVL soddisfa la proprietà di essere 1-bilanciato al fine di garantire l'altezza logaritmica. Dato un nodo u, indichiamo con h(u) la sua altezza, che indentifichiamo con l'altezza del sottoalbero radicato in u, dove h . ( n u l l ) = — 1 (Paragrafo 4.1.1). Un nodo u è 1-bilanciato se le altezze dei suoi due figli differiscono per al più di un'unità |h.(u.sx) - h(u.dx)| s? 1

(5.2)

Un albero binario è 1-bilanciato se ogni suo nodo è 1-bilanciato. La connessione tra l'essere 1 -bilanciato e avere altezza logaritmica non è immediata e passa attraverso gli alberi di Fibonacci, che sono un sottoinsieme degli alberi 1-bilanciati con il minor numero di nodi a parità di altezza. In altre parole, indicato con Fibh un albero di Fibonacci di altezza h e con n ^ il suo numero di nodi, eliminando un solo nodo da Fib^ otteniamo che l'altezza diminuisce o che l'albero risultante non è più 1-bilanciato: nessun albero 1-bilanciato con n nodi e altezza h può dunque avere meno di rih nodi, ossia n ^ n.h. Mostrando che n ^ ^ c h per un'opportuna costante c > 1, deriviamo che n ^ c H e, quindi, che h. = O(logn).

Fibo

Fib\

7

' Figura 5.1

Fibì

Fib-i

FibH

A

Alberi di Fibonacci.

Gli alberi di Fibonacci FibH di altezza h. sono definiti ricorsivamente (Figura 5.1): per h. = 0, abbiamo un solo nodo, per cui no = 1, e, per h. = 1, abbiamo un albero con n i = 2 nodi (la radice e un solo figlio, che nella figura è quello sinistro). Per h. > 1, l'albero Fibh è costruito prendendo un albero Fib^-i e un albero /7'£H-2> le c u i radici diventano i figli di una nuova radice (quella di Fibh). In tal caso, abbiamo che rih = rih-1 + tvh-2 + 1) relazione ricorsiva che ricorda quella dei numeri di Fibonacci (Paragrafo 2.6.2) motivando così il nome di tali alberi. Possiamo osservare nella Figura 5.1 che Fibo e Fib\ sono alberi 1-bilanciati di altezza 0 e 1, rispettivamente, con il minimo numero di nodi possibile. Ipotizzando che, per induzione, tale proprietà valga per ogni i < h. con h. > 1, mostriamo come ciò sia vero anche per FibH ragionando per assurdo. Supponiamo di poter rimuovere un nodo da Fibh mantenendo la sua altezza h. e garantendo che rimanga 1-bilanciato: non potendo rimuovere la radice, tale nodo deve appartenere a Fib<^_ \ oppure a F i b ^ - i per costruzione. Ciò è impossibile in quanto questi ultimi sono minimali per ipotesi induttiva e, se Fibh-\ cambiasse altezza, anche Fib^ la cambiarebbe, mentre se H ^ h - 2 cambiasse altezza, Fibh non sarebbe più 1-bilanciato. Quindi, anche FibH è minimale e concludiamo che ogni albero 1-bilanciato di altezza h. con n nodi soddisfa n ^ Tabulando i primi 15 valori di n ^ e altrettanti numeri di Fibonacci Fh, possiamo verificare per ispezione diretta che vale la relazione rih = Fh+3 — 1: h Fh

0 1 0

1 2 1

2 4 1

3 7 2

4 12 3

5 20 5

6 33 8

7 54 13

8 88 21

9 143 34

10 232 55

11 376 89

12 609 144

13 986 233

14 1596 377

Utilizzando la nota forma chiusa dei numeri di Fibonacci F

^

-

^ v5

,

possiamo affermare che FH > ^ ^ FH > c

H

dovecJ> = ! ± ^ l , 2 e

6180339...

che, quindi, esiste una costante c > 1 tale che

per h. > 2. Pertanto, n n = F h + 3 — 1 ^ c h e, poiché n ^

possiamo

InserisciC u, e ) : IF (u == nuli) { RETURN f = NuovaFoglia( e ); } ELSE IF (e.chiave < u.dato.chiave) { u.sx = InserisciC u.sx, e ); IF (Altezza(u.sx) - Altezza(u.dx) == 2) { IF (e.chiave>u.sx.dato.chiave) u.sx=RuotaAntiOraria(u.sx); u = RuotaOrariaC u );

> } ELSE IF (e.chiave > u.dato.chiave) { u.dx = InserisciC u.dx, e ); IF (Altezza(u.dx) - AltezzaCu.sx) == 2) { IF (e.chiave < u.dx.dato.chiave) u.dx = RuotaOraria(u.dx); u = RuotaAntiOrariaC u );

> u.altezza = max( Altezza(u.sx), Altezza(u.dx) ) + 1; RETURN U;

AltezzaC u ): IF (u == nuli) { RETURN -1; > ELSE {

RETURN u.altezza;

NuovaFogliaC e ): u = NuovoNodoO; u.dato = e; u.altezza = 0; u.sx = u.dx = nuli; RETURN u;

Codice 5.7

Algoritmo per l'inserimento di un elemento e in un albero AVL con radice u.

concludere che n ^ c h : in altre parole, ogni albero 1-bilanciato di n nodi e altezza h. verifica h. = O(logn). Per implementare gli alberi AVL, introduciamo un ulteriore campo u . a l t e z z a nei suoi nodi u, tale che u . a l t e z z a = h(u). Notiamo che l'operazione di ricerca negli alberi AVL rimane identica a quella descritta nel Codice 5.5. Mostriamo quindi nel Codice 5.7 come estendere l'inserimento per garantire che l'albero AVL rimanga 1-bilanciato. Dopo la creazione della foglia f contenente l'elemento e (riga 3), aggiorniamo le altezze ricorsivamente nei campi u . a l t e z z a degli antenati u di f, essendo questi ultimi i soli nodi che possono cambiare altezza (riga 17). Allo stesso tempo, controlliamo se il nodo corrente è 1-bilanciato: definiamo nodo critico il minimo antenato di f che viola tale proprietà. A tal fine, percorriamo in ordine inverso le chiamate ricorsive sugli antenati di f (righe 5 e 11), fino a individuare il nodo critico u, se esiste: in tal caso, se f discende da

RuotaOraria( z ): v = z.sx; z.sx = v.dx; v.dx = z; z.altezza = max( Altezza(z.sx), Altezza(z.dx) v.altezza = max( Altezza(v.sx), Altezza(v.dx)

i; l;

RETURN V;

RuotaAntiOraria( v ): z = v.dx; v.dx = z.sx; z.sx = v; v.altezza = max( Altezza(v.sx), Altezza(v.dx) z.altezza = max( Altezza(z.sx), Altezza(z.dx)

1;

RETURN Z; Codice 5.8

Rotazioni oraria e antioraria.

u . sx, l'altezza del sottoalbero sinistro di u differisce di due rispetto a quella del destro (riga 6), mentre se f discende da u . dx, abbiamo che è l'altezza del sottoalbero destro di u a differire di due rispetto a quella del sinitro (riga 12). Comunque vada, aggiorniamo l'altezza del nodo prima di terminare la chiamata attuale (riga 17). Discutiamo ora come ristrutturare l'albero in corrispondenza del nodo critico u, utilizzando le rotazioni orarie e antiorarie per rendere nuovamente u un nodo 1-bilanciato (righe 7 - 8 e 13-14): tali rotazioni sono illustrate e descritte nel Codice 5.8. Notiamo che esse richiedono 0 ( 1 ) tempo e preservano la proprietà di ricerca: le chiavi in a sono minori di v . d a t o . c h i a v e ; quest'ultima è minore delle chiavi in (3, le quali sono minori di z . d a t o . c h i a v e ; infine, quest'ultima è minore delle chiavi in y. Utilizziamo le rotazioni per trattare i quattro casi che si possono presentare (individuati con un semplice codice mnemonico), in base alla posizione di f rispetto ai nipoti del nodo critico u (Figura 5.2): 1. caso SS: la foglia f appartiene al sottoalbero a radicato in u . s x . sx; 2. caso SD: la foglia f appartiene al sottoalbero (3 radicato in u . s x . dx;

Figura 5.2

I quattro casi possibili di sbilanciamento del nodo crìtico u a causa della creazione della foglia f (contenente la chiave k).

3. caso DS: la foglia f appartiene al sottoalbero y radicato in u . d x . sx; 4. caso D D : la foglia f appartiene al sottoalbero 6 radicato in u . d x . dx. In tutti e quattro i casi, lo sbilanciamento conduce l'albero AVL in una configurazione in cui due sottoalberi hanno un dislivello pari a due. Con riferimento all'inserimento descritto nel Codice 5.7, trattiamo il caso SS con una rotazione oraria effettuata sul nodo critico u, riportando l'altezza del sottoalbero a quella immediatamente prima che la foglia f venisse creata (riga 8). Se invece incontriamo il caso SD, prima effettuiamo una rotazione antioraria sul figlio sinistro di u (riga 7) e poi una oraria su u stesso (riga 8): anche in tal caso, l'altezza del sottoalbero torna a essere quella immediatamente prima che la foglia f venisse creata (Figura 5.3). I casi D D e DS sono speculari: effettuiamo una rotazione antioraria su u (riga 14) oppure una rotazione oraria sul figlio destro di u seguita da una oraria su u (righe 13 e 14). Siccome ogni caso richiede una o due rotazioni, il costo è 0(1) tempo per eseguire le rotazioni (al più due), a cui va aggiunto il tempo di inserimento O(logn).

ALVIE:

i n s e r i m e n t o in alberi A V L cEHD>

Osserva, sperimenta e verifica Avllnsert

cwiTì CjTTTp (TT7TT)

Ctna>CIIi&CE3)

dmr>

crnrn OUI!> OTTTT)t cTTTTTtcrnT»

Per la cancellazione, possiamo trattare dei casi simili a quelli dell'inserimento, solo che possono esserci più nodi critici tra gli antenati del nodo cancellato: preferiamo quindi marcare logicamente i nodi cancellati, che vengono ignorati ai fini della ricerca. Quando una frazione costante dei nodi sono marcati come cancellati, ricostruiamo l'albero con le sole chiavi valide ottenendo un costo ammortizzato di O(logn). Possiamo trasformare il costo ammortizzato in un costo al caso pessimo interlacciando la ricostruzione dell'albero, che produce una copia dell'albero attuale, con le operazioni normalmente eseguite su quest'ultimo. Nonostante siano stati concepiti diverso tempo fa, gli alberi AVL sono tuttora molto competitivi rispetto a strutture di dati più recenti: la maggior parte delle rotazioni avvengono negli ultimi due livelli di nodi, per cui gli alberi AVL risultano molto efficienti se implementati opportunamente (all'atto pratico, la loro forma è molto vicina a quella di un albero completo e quasi perfettamente bilanciato).

5.5

Opus libri: basi dati e B-alberi

Le basi di dati (database) sono al centro dei sistemi informativi di aziende, enti pubblici e privati, in quanto permettono di organizzare, in forma permanente, una grande quantità di dati strutturati in un formato predefinito (record) mettendoli in relazione tra di loro e rendendoli disponibili, in modo uniforme e controllato, ad applicazioni eterogenee (attraverso le transazioni concorrenti che mantengono l'integrità dei dati e la loro specifica in un opportuno linguaggio di interrogazione come, per esempio, SQL ovvero Structured Query Languagé). I sistemi per la gestione di basi di dati (DBMS o Data Base Management System) utilizzano diverse strutture di dati, chiamate indici, per garantire un accesso veloce ai dati richiesti dalle transazioni in corso. Possiamo modellare, semplificandolo, il problema di costruire un indice per un DBMS in termini di un insieme S = {eo, e¡,..., e n _ i } di n record, dove ciascun record è caratterizzato da una chiave di ricerca primaria che lo identifica univocamente (per esempio, il codice fiscale se il record è riferito alle persone). I record possono contenere ulteriori chiavi di ricerca, dette secondarie, che esprimono i loro attributi aggiuntivi, non necessariamente in modo univoco (per esempio, la nazionalità o la città di residenza). Possiamo realizzare un tale indice usando la struttura di

dati del dizionario: oltre a liste e tabelle hash, la struttura di dati principale per realizzare l'indice nei DBMS è il B-albero (B-tree). Prima di descrivere in dettaglio il B-albero, presentiamo lo scenario entro cui valutare il suo costo computazionale estendendo il modello RAM (Paragrafo 1.4). Nel seguito supponiamo che la RAM abbia accesso a due livelli di memoria: al primo livello, detto memoria principale, aggiungiamo un secondo livello, detto memoria secondaria o disco e diviso in blocchi di memoria, ciascun blocco contenente un numero di celle di memoria consecutive pari a d i m e n s i o n e B l o c c o . L'accesso alla memoria di secondo livello non è diretto, contrariamente al primo livello, ma avviene esclusivamente attraverso delle primitive che permettono di leggere o scrivere un blocco di memoria, consentendo il suo trasferimento da e verso la memoria principale. Tale blocco può essere quindi elaborato con le operazioni della RAM nella memoria principale: ai nostri fini, trattiamo un blocco b, una volta caricato nella memoria principale, come un normale array b di d i m e n s i o n e B l o c c o elementi. Nella memoria secondaria, i blocchi sono univocamente identificati da interi positivi distinti che consideriamo essere i loro indirizzi logici a tutti gli effetti. Il blocco b è quindi identificato dal suo indirizzo i > 0 quando decidiamo di trasferirlo tra i due livelli di memoria: notiamo che l'indirizzo logico 0 è riservato e rappresenta l'indirizzo vuoto (ovvero, nessun blocco corrisponderà mai a tale indirizzo). Le seguenti primitive gestiscono il trasferimento di blocchi, dove b è un array di d i m e n s i o n e B l o c c o elementi nella memoria principale e i > 0 è l'indirizzo logico di un blocco nella memoria secondaria: • b = L e g g i D a D i s c o ( i ) trasferisce il blocco con indirizzo i dalla memoria secondaria alla memoria principale, dove diventa accessibile come array b; • i = C r e a S u D i s c o ( b ) trasferisce l'array b dalla memoria principale alla memoria secondaria, creando lo spazio opportuno per ospitarlo come blocco e restituendo l'indirizzo i assegnato a tale blocco nella memoria secondaria; • A g g i o r n a S u D i s c o f b , i) trasferisce l'array b dalla memoria principale alla memoria secondaria, sovrascrivendo lo spazio di memoria secondaria allocato in precedenza al blocco con indirizzo i. Al costo computazionale in termini di tempo e di spazio, aggiungiamo un ulteriore costo, chiamato numero di trasferimenti, che conteggia il numero di blocchi trasferiti tra i due livelli di memoria, ovvero il numero di volte che le suddette primitive sono invocate all'interno degli algoritmi: il motivo è che l'accesso al disco è di diversi ordini di grandezza più lento di quello alla memoria principale. Al termine dell'esecuzione di un algoritmo, i dati persistenti sono esclusivamente quelli che risiedono in memoria secondaria, mentre quelli presenti nella memoria principale sono considerati persi (come avviene in molti calcolatori). Il numero di trasferimenti richiesti dalle operazioni sugli alberi di ricerca come gli AVL è elevato nel modello a due livelli di memoria: infatti, ogni accesso a un nodo

c E 29 18 36

-OO

Figura 5.4

,

»131

-

C D

23 57

-

cuCD Kj

-oo A B 0 97 43

o 13! E F

41 64

o 12

Esempio di B-albero con B = 4 (primi due livelli di blocchi), visto come indice per n = 7 record di cui uno fittizio (ultimo livello), le cui chiavi primarie sono A, B F (oltre alla sentinella -oo). I numeri in corsivo rappresentano il grado dei nodi del B-albero, gli altri numeri sono gli indirizzi logici dei blocchi e le frecce segnalano il loro uso come riferimenti. Ciascun blocco è rappresentato ripiegato su se stesso a fini illustrativi.

può causare uno o più trasferimenti e, pertanto, le operazioni sul dizionario richiedono O(logn) trasferimenti ciascuna. Inoltre, non sfruttiamo il fatto che una volta trasferito un blocco, abbiamo d i m e n s i o n e B l o c c o elementi a disposizione. Sia B ^ 4 il più grande intero pari tale che B ^ ( d i m e n s i o n e B l o c c o — 2 ) / 2 (in altre parole, un blocco di memoria secondaria può contenere fino a 2 x B + 2 elementi). Per semplificare la discussione, ipotizziamo che ciascun record occupi esattemente un blocco di memoria secondaria e abbia una chiave primaria su cui costruire l'indice di ricerca. Mostriamo come ottenere un dizionario che richiede 0(log B n) trasferimenti, fornendo un costo ottimo nella ricerca per confronti in quanto possiamo mostrare, attraverso una generalizzazione del limite inferiore discusso per la ricerca binaria (Paragrafo 2.4.2), che occorrono 0 ( l o g B n) trasferimenti. Un B-albero (precisamente, un B + -albero) per n record ha 0 ( n / B ) nodi, dove ciascun nodo è di grado (numero di figli) variabile compreso tra B/2 e B — 1 (esclusa la radice, che può avere grado compreso tra 2 e B — 1) e contiene un sottoinsieme delle chiavi primarie contenute nei suoi figli, in numero pari al proprio grado: in particolare, le chiavi nei padri sono una replica della minima chiave contenuta in ciascuno dei figli (e tale proprietà vale ricorsivamente nei figli). Inoltre, i nodi allo stesso livello (cioè alla stessa profondità) sono collegati in una lista ordinata: questo è utile in particolare per accedere' alla sequenza ordinata di tutte le chiavi distinte del B-albero, che sono quelle memorizzate nelle foglie (queste ultime hanno tutte lo stesso livello). Mostriamo un esempio di B-albero con B = 4 nella Figura 5.4, dove utilizziamo un record fittizio con la chiave speciale —oo < k, per ogni k e U, che funge da sentinella negli algoritmi che mantengono tale struttura di dati. Possiamo riassumere le caratteristiche di un B-albero come segue (dove B ^ 4 pari è un parametro della definizione del B-albero, che dipende

dalla dimensione del blocco di memoria e da cui dipende la complessità delle operazioni definite sul B-albero): 1. ciascun nodo u del B-albero è implementato come un array u di 2 x B + 2 elementi (di cui almeno la metà sono utilizzati) e, risiedendo in un blocco di memoria, è univocamente individuato dal suo indirizzo logico; 2. i primi B elementi dell'array u contengono un numero variabile g di chiavi primarie dei record, dove B/2 ^ g < B tranne che per la radice, in cui 2 < g < B (la cardinalità g delle chiavi può variare da nodo a nodo e, per questo motivo, è memorizzata nell'elemento u[2 x B + 1]); 3. i successivi B elementi dell'array contengono g indirizzi logici associati alle chiavi (tali indirizzi conducono ai figli dei nodi interni oppure ai record collegati alle foglie): u[r] contiene la minima chiave primaria che appare nel nodo o record indicato da u[B + r], per 0 ^ r ^ g; 4. le foglie sono tutte allo stesso livello, denominato 0, e se un nodo u ha livello i, allora suo padre ha livello i + 1 (inoltre, l'elemento u[2 x B] contiene l'indirizzo del nodo successivo a u nel livello i): in tal modo, l'altezza h. del B-albero è data dal livello della radice; 5. le chiavi in ogni nodo u soddisfano la proprietà di ricerca: per ogni 0 < r < g, la chiave in u[r] è maggiore delle chiavi in u[0, r— 1] e di quelle raggiungibili nei nodi discendenti, attraverso i riferimenti in u[B, B + r — 1]; inoltre, essa è minore delle chiavi in u [ r + 1, g] e minore o uguale di quelle raggiungibili nei nodi discendenti, attraverso i riferimenti in u[B + r, B + g]. Oltre ai blocchi di un B-albero, dobbiamo memorizzare la sua altezza e l'indirizzo logico della radice. Come si può osservare dalla Figura 5.4, il numero di nodi (blocchi) in un B-albero per n record è pari a 0 ( n / B ) e la sua altezza è h = 0(log B n) poiché, a parte la radice, ogni nodo ha grado minimo pari a B/2: quindi la radice ha almeno due figli, almeno 2 x B/2 nipoti, almeno 2 x (B/2) 2 pronipoti, e così via, fino a trovare almeno 2 ( B / 2 ) h _ 1 foglie. Essendo queste ultime in numero pari a 0 ( n / B ) , abbiamo che 2 ( B / 2 ) h _ 1 = 0 ( n / B ) , per cui H = O( ) = 0(log B TI). Nei moderni sistemi di calcolo, il valore di d i m e n s i o n e B l o c c o è tale che B è dell'ordine delle migliaia: pertanto, con un B-albero di soli due livelli (h. = 1) possiamo indicizzare milioni di record, mentre con un ulteriore livello arriviamo a indicizzarne miliardi. Usando le proprietà esposte sopra, possiamo vedere come effettuare un'operazione R i c e r c a di una chiave k in un B-albero di cui conosciamo l'altezza e l'indirizzo logico della radice, come mostrato nel Codice 5.9. Partendo dalla radice (di cui conosciamo l'indirizzo) e dall'altezza dell'albero, che sono i parametri d'ingresso di R i c e r c a , carichiamo dalla memoria secondaria un nodo per ogni livello (riga 3): su tale nodo, ora presente in memoria principale, effettuiamo la ricerca binaria ricorsiva (riga 5) descritta nel Paragrafo 2.5, la quale permette di calcolare il rango di k nell'array ordinato formato

Ricercai indirizzo, altezza, k ): FOR (livello = altezza; livello >= 0; livello = livello - 1) { nodo = LeggiDaDisco( indirizzo ); card = nodo[2 x B + 1]; rango = RicercaBinariaRicorsivaC nodo[0, card-I] , k) ; indirizzo = nodo [B + rango - 1];

> RETURN

indirizzo;

Inserisci( indirizzoRadice, altezza, e ): = InsRicC indirizzoRadice, altezza, e ); IF (indirizzoN != 0) { buffer[0] = - o o ; buffer[B] = indirizzoRadice; buffer[1] = chiave; buffer[B + 1] = indirizzoN; buffer[2 x B] = 0 ; buffer[2 x B + 1] = 2; indirizzoRadice = CreaSuDiscoC buffer ); altezza = altezza+1;

> RETURN
Ricerca e inserimento in un B-albero di cui conosciamo l'altezza (pari a - 1 se l'albero è vuoto) e l'indirizzo logico della radice (pari a 0 se l'albero è vuoto).

dalle chiavi del nodo (ricordiamo che il rango è il numero di chiavi minori o uguali a k). Il prossimo figlio da caricare è indicato quindi nel riferimento associato alla chiave avente tale rango come posizione (riga 6). Terminiamo quando troviamo un record (ovvero, l i v e l l o è negativo), e quindi restituiamo tale record (se la chiave k appare, deve apparire in tale record e come campo e . c h i a v e ) . Non è difficile modificare la ricerca in modo che esca dal ciclo quando l i v e l l o è zero, così da elencare i record e con e. c h i a v e ^ k seguendo l'ordine indicato dalle foglie del B-albero (usando il riferimento alla prossima foglia memorizzato nell'elemento f[2 x B] della foglia corrente f). Poiché effettuiamo il trasferimento di h = 0(log B n) blocchi, il numero totale di trasferimenti è 0 ( l o g B n). Inoltre il tempo di ricerca, oltre a quello necessario per i trasferimenti, è OflogB x log B n) = O(logn) perché la ricerca binaria richiede O(logB) tempo per ciascuno degli h. livelli. Per quanto riguarda l'operazione I n s e r i s c i , osserviamo che la modalità di bilanciamento del B-albero differisce da quella dell'albero AVL, basata sulle rotazioni e sulla crescita dell'albero verso le foglie: nel caso del B-albero, la crescita è verso l'alto, con la

creazione di nuove radici. Precisamente, quando un nodo u contiene B chiavi, allora creiamo un nuovo fratello u ' alla sua destra, che prende le ultime B/2 chiavi (quelle più grandi) da u. In tal modo, otteniamo due nodi con B/2 chiavi ciascuno e, inoltre, una copia della chiave minima in u ' sale, insieme all'indirizzo logico di u ' , nel padre dei due nodi u e u ' . Tale operazione prende il nome di divisione (split) e richiede l'inserimento di una nuova chiave (e l'indirizzo a essa associato) nel padre, il quale a sua volta può arrivare a contenere B chiavi, richiedendo esso stesso una divisione. Il meccanismo può quindi propagarsi nel caso pessimo di figlio in padre fino alla radice, la cui divisione crea una nuova radice con due figli (motivando la condizione che 2 ^ g < B per la sola radice). Inoltre, l'uso della chiave fittizia —oo permette di mantenere l'invariante che l'inserimento di una chiave non cambia mai la minima chiave del nodo corrente u, evitando così di dover riorganizzare l'associazione tra chiavi u[r] e indirizzi u[B + r]. Il meccanismo suddetto è descritto nel Codice 5.9, il quale inserisce il record e (riga 2) ricorsivamente nella radice (che può anche essere vuota, per cui va posta la sua altezza al valore —1 la prima volta che invochiamo I n s e r i s c i ) . Se necessario, crea una nuova radice utilizzando un array di appoggio b u f f e r ponendo la chiave speciale —oo come minima nel nuovo nodo (righe 4 e 5) e la chiave salita dal basso nella posizione successiva (righe 6 e 7). Gli indirizzi logici dei figli subiscono un trattamento analogo. Inoltre, il riferimento al successore è sempre nullo per la radice (riga 8), e l'elemento in ultima posizione assume come valore la cardinalirà dell'insieme delle due chiavi nella radice (riga 9). Infine, la nuova radice viene trasferita in memoria secondaria, annotando l'indirizzo logico assegnatole (riga 10) e incrementando l'altezza (riga 11). Resta da discutere l'inserimento ricorsivo, descritto nel Codice 5.10, e come esso gestisce le divisioni che possono propagarsi verso l'alto. La ricorsione ha come caso base (riga 2) l'allocazione in memoria secondaria del record e che contiene la chiave k (dove e . c h i a v e = k), restituendo la coppia formata dalla chiave k stessa e dall'indirizzo logico assegnato al record e (in modo da poterli inserire nell'opportuna foglia del B-albero). Nello schema ricorsivo, dopo aver caricato in memoria principale il nodo del livello corrente (riga 3) e aver determinato il numero di chiavi in esso contenute (riga 4), effettuiamo una ricerca binaria ricorsiva per determinare il rango (riga 5), come nell'operazione R i c e r c a . A questo punto, inseriamo ricorsivamente la chiave k nel figlio del nodo nella posizione individuata dal rango (riga 6). La chiamata ricorsiva restituisce una coppia formata da una chiave e dall'indirizzo logico corrispondente (quello di u ' se il figlio u ha subito una divisione oppure, se siamo in una foglia, quello del nuovo record appena inserito nel caso base). Se l'indirizzo logico è 0, vuol dire che non dobbiamo propagare alcunché nel nodo corrente e nei suoi antenati (riga 28). Altrimenti (righe 7—27), dobbiamo far posto alla

InsRicC indirizzo, livello, e ): IF (livello < 0) RETURN ; nodo = LeggiDaDiscoC indirizzo ); card = nodo[2 x B + 1]; rango = RicercaBinariaRicorsivaC nodo[0, card-1], e.chiave ); = InsRicC nodo[B+rango-1], livello-1, e); IF (indirizzoN != 0) { FOR (i = card; i > rango; i = i - 1) { nodo[i] = nodo[i-l]; nodo[B + i] = nodo[B + (i - 1)];

> nodo[rango] = chiave; nodo[B + rango] = indirizzoN; nodo[2 x B + 1] = card + 1; AggiornaSuDiscoC nodo, indirizzo ); IF (nodo [2 x B + 1] == B) { FOR (i = 0; i < B/2; i = i + 1) { buffer [i] = nodo[B/2+i]; buffer[B + i] = nodo[B + (B/2+i)];

> buffer[2 x B + 1] = nodo[2 x B + 1] = B/2; buffer[2 x B] = nodo[2 x B]; nodo[2 x B] = CreaSuDiscoC buffer ); AggiornaSuDiscoC nodo, indirizzo ); RETURN
B]>;

> > RETURN <0, 0>

Codice 5.10

Inserimento ricorsivo in un B-albero.

chiave salita dal basso (righe 8 - 1 1 ) ponendola nella posizione corrispondente al rango precedentemente calcolato con la ricerca binaria ricorsiva (riga 12), con l'indirizzo associato a essa nella posizione corrispondente (riga 13), e incrementando il numero di chiavi presenti nel nodo (riga 14). Dopo aver salvato il nodo sulla memoria secondaria (riga 15), controlliamo se va diviso (riga 16): in tal caso prendiamo le B / 2 chiavi più grandi e i loro indirizzi associati e le poniamo in un array di appoggio b u f f e r (righe 17-20), che diventerà il fratello destro del nodo corrente. Aggiustiamo la loro cardinalità (riga 21) e colleghiamo il nuovo nodo mediante un riferimento (riga 22) per agganciarlo al resto dei nodi nella lista ordinata per quel livel-

lo. Possiamo quindi salvare nella memoria secondaria b u f f e r come fratello destro del nodo corrente (riga 23), che a sua volta va salvato con la sua nuova configurazione delle chiavi (riga 24). Facciamo quindi salire al padre del nodo corrente la chiave minima che appare nella posizione zero del suo nuovo fratello, associandogli l'indirizzo logico di esso (riga 25). L'inserimento in un B-albero richiede 0 ( 1 ) trasferimenti per livello e, quindi, ha un costo totale di 0 ( l o g B n ) trasferimenti, come la ricerca. A differenza della ricerca, il tempo totale di calcolo, a parte i trasferimenti, è 0 ( B l o g B n ) perché ciascun livello richiede 0(B) tempo: tuttavia, tale tempo è trascurabile rispetto a quello richiesto per trasferire i blocchi da e verso la memoria secondaria. Per quanto riguarda l'operazione di cancellazione, anch'essa può essere realizzata con lo stesso costo dell'inserimento, solo che invece dell'operazione di divisione utilizziamo l'operazione di fusione. Analogamente a quanto detto per gli alberi AVL, consigliamo però di cancellare logicamente le chiavi e di ricostruire periodicamente il B-albero con le sole chiavi non marcate come cancellate. Un'ultima osservazione riguarda l'uso dei B-alberi in memoria principale: fissando B = 4 otteniamo un albero di ricerca bilanciato alternativo agli alberi AVL, chiamato 2-3-albero, che ha lo stesso costo O(logn) per operazione. Inoltre, il modo con cui ricopiamo le chiavi nei livelli superiori è reminiscente di quanto succede nell'organizzazione delle skip list (Paragrafo 3.3). Infine, modificando leggermente il B-albero (B = 4) e colorando alternativamente i livelli dei nodi con il rosso e il nero, è possibile ottenere una forma equivalente a un'altra famiglia di alberi bilanciati, detti alberi rosso-neri (noti come red-black tree e usati per gestire le VMA del kernel Linux). ALVIE:

ricerca e inserimento in B-alberi

Osserva, sperimenta e verifica BTree

5.6

Opus libri: liste invertite e trie

Nei sistemi di recupero dei documenti (information retrieval), i dati sono documenti testuali e il loro contenuto è relativamente stabile: pertanto, in tali sistemi lo scopo principale è quello di fornire una risposta veloce alle numerose interrogazioni degli utenti (contrariamente alle basi di dati che sono progettate per garantire un alto flusso di transazioni che ne modificano i contenuti). In tal caso, la scelta adottata è quella di elaborare preliminarmente l'archivio dei documenti per ottenere un indice in cui le ricerche siano

molto veloci, di fatto evitando di scandire l'intera collezione dei documenti a ogni interrogazione (come vedremo, i motori di ricerca sul Web rappresentano un noto esempio di questa strategia). Infatti, il tempo di calcolo aggiuntivo che è richiesto nella costruzione degli indici, viene ampiamente ripagato dal guadagno in velocità di risposta alle innumerevoli richieste che pervengono a tali sistemi. Le liste invertite (chiamate anche file invertiti, file dei posting o concordanze) costituiscono uno dei cardini nell'organizzazione di documenti in tale scenario. Le consideriamo un'organizzazione logica dei dati piuttosto che una specifica struttura di dati, in quanto le componenti possono essere realizzate utilizzando strutture di dati differenti. La nozione di liste invertite si basa sulla possibilità di definire in modo preciso la nozione di termine (inteso come una parola o una sequenza massimale alfanumerica), in modo da partizionare ciascun documento o testo T della collezione di documenti D in segmenti disgiunti corrispondenti alle occorrenze dei vari termini (quindi le occorrenze di due termini non possono sovrapporsi in T). La struttura delle liste invertite è infatti riconducibile alle seguenti due componenti (ipotizzando che il testo sia visto come una sequenza di caratteri): • il vocabolario o lessico V, contenente l'insieme dei termini distinti che appaiono nei testi di D; • la lista invertita Lp (detta dei posting) per ciascun termine P G V, contenente un riferimento alla posizione iniziale di ciascuna occorrenza di P nei testi T E D: in altre parole, la lista per P contiene la coppia (T, i) se il segmento T[i, i + |P| — 1] del testo è proprio uguale a P (ogni documento T € D ha un suo identificatore numerico che lo contraddistingue dagli altri documenti in D). Notiamo che le liste invertite sono spesso mantenute in forma compressa per ridurre lo spazio a circa il 10-25% del testo e, inoltre, le occorrenze sono spesso riferite al numero di linea piuttosto che alla posizione precisa nel testo. Solitamente, la lista invertita Lp memorizza anche la sua lunghezza in quanto rappresenta la frequenza del termine P nei documenti in D. Per completezza, osserviamo che esistono metodi alternativi alle liste invertite come le bitmap e i signature file, ma osserviamo anche che tali metodi non risultano superiori alle liste invertite come prestazioni. La realizzazione delle liste invertite prevede l'utilizzo di un dizionario (tabella hash o albero di ricerca) per memorizzare i termini P € V: nello specifico, ciascun elemento e memorizzato nel dizionario ha un distinto termine P G V contenuto nel campo e . c h i a v e e ha un'implementazione della corrispondente lista Lp nel campo e . s a t . Nel seguito, ipotizziamo quindi che e . s a t sia una lista doppia che fornisce le operazioni descritte nel Paragrafo 5.2; inoltre, ipotizziamo che un termine sia una sequenza massimale alfanumerica nel testo dato in ingresso. Il Codice 5.11 descrive come costruire le liste invertite usando un dizionario per memorizzare i termini distinti, secondo quanto abbiamo osservato sopra. Lo scopo è

CostruzioneListelnvertiteC T ) : (pre: T e D è un testo di lunghezza n) i = 0; WHILE ( i < n ) { WHILE (i < n kk ¡AlfaNumericoC T[i] )) i = i+1; 3 = ì; WHILE (j < n ft& AlfaNumericoC T[j] )) j = j+i; e = dizionarioListelnvertite.Ricercai T[i,j-1] ); IF (e != nuli) { e.sat.InserisciFondoC ); > ELSE

{

elemento.chiave = T[i,j-1]; elemento.sat = NuovaListaC ); elemento.sat.InserisciFondoC ); dizionarioListelnvertite.Inserisci( elemento )

>

>

i = j;

AlfaNumericoC c ): RETURN

('a' <= c <=

'z'

Il

'A' <= c <=

'Z'

Il

'0' <= c <=

'9');

Codice 5.11 Costruzione di liste invertite di un testo T e D (elemento indica un nuovo elemento).

quello di identificare una sequenza alfanumerica massima rappresentata dal segmento di testo T[i, j — 1] per i < j (righe 4—8): tale termine viene cercato nel dizionario (riga 9) e, se appare in esso, la coppia (T, i) che ne denota l'occorrenza in T viene posta in fondo alla corrispondente lista invertita (righa 11); se invece T[i, j — 1] non appare nel dizionario, tale lista viene creata e memorizzata nel dizionario (righe 13—16). ALVIE:

costruzione delle liste invertite Osserva, sperimenta e verifica InvertedList

CE> <Œ> &> -

Supponendo che n sia il numero totale di caratteri esaminati, il costo della costruzione descritta nel Codice 5.11 è pari a O(n) al caso medio usando le tabelle hash e O ( n l o g n ) usando gli alberi di ricerca bilanciati. Nei casi reali, la costruzione è concet-

tualmente simile a quella descritta nel Codice 5.11 ma notevolmente differente nelle prestazioni. Per esempio, dovremmo aspettarci di applicare tale codice a una vasta collezione di documenti che, per la sua dimensione, viene memorizzata nella memoria secondaria in cui l'accesso è a blocchi (come specificato nel Paragrafo 5.5). Per le liste invertite, potremmo memorizzare anche le varie liste Lp nella memoria secondaria mentre il dizionario per il solo vocabolario V rimarrebbe in memoria principale; oppure, potremmo usare un B-albero per mantenere anche V in memoria secondaria. Ne risulta che, per l'analisi del costo finale, possiamo utilizzare il modello di memoria a due livelli valutando le varie decisioni progettuali: di solito, il vocabolario V è mantenuto in memoria principale, mentre le liste e i documenti risiedono in memoria secondaria; tuttavia, diversi motori di ricerca memorizzano anche le liste invertite (ma non i documenti) nella memoria principale utilizzando decine di migliaia di macchine in rete, ciascuna dotata di ampia memoria prinicipale a basso costo. Per quanto riguarda le interrogazioni effettuate in diversi motori di ricerca, esse prevedono l'uso di termini collegati tra loro mediante gli operatori booleani: l'operatore di congiunzione (AND) tra due termini prevede che entrambi i termini occorrano nel documento; quello di disgiunzione (OR) prevede che almeno uno dei termini occorra; infine, l'operatore di negazione (NOT) indica che il termine non debba occorrere. E possibile usufruire anche dell'operatore di vicinanza ( N E A R ) come estensione dell'operatore di congiunzione, in cui viene espresso che i termini specificati occorrano a poche posizioni l'uno dall'altro. Tali interrogazioni possono essere composte come una qualunque espressione booleana, anche se le statistiche mostrano che la maggior parte delle interrogazioni nei motori di ricerca consiste nella ricerca di due termini connessi dall'operatore di congiunzione. Le liste invertite aiutano a formulare tali interrogazioni in termini di operazioni elementari su liste, supponendo che ciascuna lista Lp sia ordinata. Per esempio, l'interrogazione (P AND Q) altro non è che l'intersezione tra Lp e Lq, mentre (P OR Q) ne è l'unione senza ripetizioni: entrambe le operazioni possono essere svolte efficientemente con una variante dell'algoritmo di fusione adoperato per il mergesort (Paragrafo 2.5.3). L'operazione di negazione è il complemento della lista e, infine, l'interrogazione (P NEAR Q) è anch'essa una variante della fusione delle liste Lp e Lq, come discutiamo ora in dettaglio a scopo illustrativo (le interrogazioni AND e OR sono trattate in modo analogo): a tale scopo, ipotizziamo che le coppie in Lp e Lq siano in ordine lessicografico crescente. Il Codice 5.12 descrive come procedere per trovare le occorrenze di due termini P e Q che distano tra di loro per al più maxPos posizioni, facendo uso del Codice 5.13 per verificare tale condizione evitando di esaminare tutte le 0(|Lp| x |Lq|): le occorrenze restituite in uscita sono delle triple composte da T, i e j, dove 0 ^ j — i ^ maxPos, a indicare che T [ i , i + |P| - 1] = P e T[j,j + |Q| - 1] = Q oppure T[i,i + |Q| - 1] = Q e T[j, j + |P| — 1] = P. Notiamo che tali triple sono fornite in uscita in ordine lessicografico

InterrogazioneNearC P, Q, maxPos ): LP = Ricercai dizionarioListelnvertite, P ); LQ = Ricercai dizionarioListelnvertite, Q ); IF (LP != nuli && LQ != nuli) { listaP = LP.sat.inizio; listaQ = LQ.sat.inizio ; WHILE (listaP != nuli && listaQ != nuli) { = listaP.dato; ctestoQ, posQ> = listaQ.dato; IF (testoP < testoQ) { listaP = listaP.succ;

(pre: maxPos ^ 0)

} ELSE IF (testoP > testoQ) {

listaQ = listaQ.succ; } ELSE IF (posP <= posQ) {

VerificaNeari listaP, listaQ, maxPos ); listaP = listaP.succ; > ELSE {

VerificaNeari listaQ, listaP, maxPos ); listaQ = listaQ.succ;

> }

> Codice 5.12

Algoritmo per la risoluzione dell'interrogazione (P NEAR Q), in cui specifichiamo anche il massimo numero di posizioni in cui P e Q possono distare.

da V e r i f i c a N e a r , considerando nell'ordinamento delle triple prima il valore di T, poi il minimo tra i e j e poi il loro massimo: tale ordine lessicografico permette di esaminare ogni testo in ordine di identificatore e di scorrere le occorrenze al suo interno riportate nell'ordine simulato di scansione del testo, fornendo quindi un utile formato di uscita all'utente dell'interrogazione (in quanto non deve saltare da una parte all'altra del testo). La funzione I n t e r r o g a z i o n e N e a r nel Codice 5.12 provvede quindi a cercare P e Q nel vocabolario utilizzando il dizionario e supponendo che i testi T nella collezione sia identificati da interi (righe 2 e 3). Nel caso che le liste invertite Lp e Lq non siano entrambe vuote, il codice provvede a scandirle come se volesse eseguire una fusione di tali liste (righe 4—22): ricordiamo che ciascuna lista è composta da una coppia che memorizza l'identificatore del testo e la posizione all'interno del testo dell'occorrenza del termine corrispettivo (P o Q). Di conseguenza, se i testi sono diversi nel nodo corrente delle due liste, la funzione avanza di una posizione sulla lista che contiene il testo con identificatore minore (righe 10—13). Altrimenti, i testi sono i medesimi per cui essa deve produrre tutte le

VerificaNear( listaX, listaY, M ): {pre: posX ^ posY) = listaX.dato; ctestoY, posY> = listaY.dato; WHILE (listaY != null && testoX == testoY && posY-posX <= M) { PRINT testoX, posX, posY; listaY = listaY.succ; = listaY.dato;

Codice 5 . 1 3

Algoritmo di verifica di vicinanza per l'interrogazione (P NEAR Q).

occorrenze vicine usando V e r i f i c a N e a r e distinguendo il caso in cui l'occorrenza di P sia precedente a quella di Q o viceversa (righe 14—19). ALVIE:

i n t e r r o g a z i o n e di v i c i n a n z a per le liste invertite

Osserva, sperimenta e verifica NearQuery

Per la complessità notiamo che, se r indica il numero di triple che soddisfano l'interrogazione di vicinanza e che, quindi, sono fornite in uscita con il Codice 5.12, il tempo totale impiegato da esso è pari a 0(|Lp| + |Lq| + r) e quindi dipende dalla quantità r di risultati forniti in uscita (output sensitive). Tale codice può essere modificato in modo da sostituire la verifica di distanza sulle posizioni con quella sulle linee del testo. Gli altri tipi di interrogazione sono trattati in modo analogo a quella per vicinanza. Per esempio, l'interrogazione con la congiunzione (AND) calcolata come intersezione di Lp e Lq richiede 0(|Lp| + |Lq|) tempo: da notare però, che se memorizziamo tali liste usando degli alberi di ricerca, possiamo effettuare l'intersezione attraverso una ricerca di ogni elemento della lista più corta tra Lp e Lq nell'albero che memorizza la più lunga. Quindi, se m = min{|Lp|, |Lq|} e n = max{|Lp|, |Lq|}, il costo è pari a O ( m l o g n ) e che, quando m è molto minore di n , risulta inferiore al costo 0 ( m + n) stabilito sopra. In generale, il costo ottimo per l'intersezione è pari 0 ( m . l o g ( n / m ) ) che è sempre migliore sia di O ( m l o g n ) che di 0 ( m + n ) . Possiamo ottenere tale costo utilizzando gli alberi che permettono la finger search, in quanto ognuna delle m ricerche richiede O(logd) tempo invece che O(logn) tempo, dove d < n è il numero di chiavi che intercorrono, in ordine di visita simmetrico, tra il nodo a cui perveniamo con la chiave attualmente cercata e il nodo a cui siamo pervenuti con la precedente chiave cercata: al caso pessimo, abbia-

mo che le m ricerche conducono a m nodi equidistanti tra loro, per cui d = 0 ( n / m ) massimizza tale costo cumulativo fornendo O ( m l o g ( n / m ) ) tempo. Tale costo motiva la strategia di risoluzione delle interrogazioni che vedono la congiunzione di t > 2 termini (invece che di soli due): prima ordiniamo le t liste invertite dei termini in ordine crescente di frequenza (pari alla loro lunghezza); poi, calcoliamo l'intersezione tra le prime due liste e, per 3 ^ i ^ t, effettuiamo l'intersezione tra l'iesima lista e il risultato calcolato fino a quel momento con le prime i — 1 liste in ordine non decrescente di frequenza. Nel considerare anche le espressioni in disgiunzione (OR), procediamo come prima per ordine di frequenza delle liste, utilizzando una stima basata sulla somma delle loro lunghezze. Notiamo, infine, che alternativamente le liste invertite possono essere mantenute ordinate in base a un ordine o rango di importanza delle occorrenze. Se tale ordine è preservato in modo coerente in tutte le liste, possiamo procedere come sopra con il vantaggio di esaminare solo i primi elementi di ciascuna lista invertita, in quanto terminiamo la scansione delle liste non appena raggiungiamo un numero sufficiente di occorrenze che sono necessariamente di rango maggiore rispetto a quelle che scopriremmo successivamente, proseguendo con la scansione: in tal modo, possiamo mediamente evitare di esaminare tutti gli elementi delle liste invertite.

5.6.1

Trie o alberi digitali di ricerca

Per realizzare il vocabolario V nelle liste invertite abbiamo utilizzato finora le tabelle hash oppure gli alberi di ricerca. Nel seguito, modelliamo i termini da memorizzare in V come stringhe di lunghezza variabile, ossia come sequenze di simboli o caratteri presi da un alfabeto L di a simboli, dove o è un valore prefissato che non dipende dalla lunghezza e dal numero delle stringhe prese in considerazione (per esempio, a = 256 per l'alfabeto ASCII mentre o = 65536 per l'alfabeto UNICODE/UTF8). Ne deriva che ciascuna delle operazioni di un dizionario per una stringa di m caratteri, richiede O(m) tempo medio con le tabelle hash oppure O ( m l o g n ) tempo con gli alberi di ricerca, dove n = |V|: in quest'ultimo caso, abbiamo O(logn) confronti da eseguire e ciascuno di essi richiede O(m) tempo. Mostriamo come ottenere un dizionario che garantisce O(m) tempo per operazione utilizzando una struttura di dati denominata trie o albero digitale di ricerca, largamente impiegata per memorizzare un insieme S = ciò, a i> • • • » a n - i di n stringhe. Il termine trie si pronuncia come la parola inglese try e deriva dalla parola inglese retrieval utilizzata per descrivere il recupero delle informazioni. I trie hanno innumerevoli applicazioni in quanto permettono di estendere la ricerca in un dizionario ai prefissi della stringa cercata: in altre parole, oltre a verificare se una data stringa P appare in S, essi permettono di trovare il più lungo prefisso di P che appare come prefisso di una delle stringhe in S (tale operazione non è immediata con le tabelle hash e con gli alberi di

c „ a „ t „a n i a - O O O O O 0 Vz a

c „a O

r

P i s a '-O-CHCHI]

O

t O

a O

V

n H

i O

]

o VP ^ - o V A a

,c 0

e I l i 0 0 0 - 0 n „a O O 0

Figura 5.5

Trie per i nomi di al cune province (a sinistra) e sua versione potata (a destra).

ricerca). A tal fine, definiamo il prefisso i della stringa P di lunghezza m, come la sua parte iniziale P[0, i], dove 0 ^ i ^ m — 1. Per esempio, la ricerca del prefisso ve nell'insieme S composto dai nomi di alcune province italiane, ovvero Catania, C a t a n z a r o , pisa, p i s t o i a , v e r b a n i a , Vercelli e v e r o n a , fornisce come risultato le stringhe verbania, V e r c e l l i e verona. Il trie per un insieme S = ao, Q i , . . . , a n _ i di n stringhe definite su un alfabeto I è un albero cardinale cr-ario (Paragrafo 4.4), i cui i nodi hanno cr figli (vuoti o meno), e la cui seguente definizione è ricorsiva in termini di S: 1. se l'insieme S delle stringhe è vuoto, il trie corrispondente a S è vuoto e viene rappresentato con n u l i ; 2. se S non è vuoto, sia S c l'insieme delle stringhe in S aventi c come carattere iniziale, dove c e I (ai soli fini della definizione ricorsiva del trie, il carattere iniziale c comune alle stringhe in S c viene ignorato e temporaneamente rimosso): il trie corrispondente a S è quindi composto da un nodo u chiamato radice tale che u.f i g l i o [ c ] memorizza il trie ricorsivamente definito per S c (alcuni dei figli possono essere vuoti). Per poter realizzare un dizionario, ciascun nodo u. di un trie è dotato di un campo u . d a t o in cui memorizzare un elemento e: ricordiamo che e ha un campo di ricerca e . c h i a v e , che è una stringa in questo scenario, e un campo e . s a t per i dati satellite, come specificato in precedenza. Mostriamo, nella parte sinistra della Figura 5.5, il trie corrispondente all'insieme S di stringhe composto dai sette nomi di provincia menzionati precedentemente.

Ricercai radiceTrie, P ): (pre: P è una stringa di lunghezza m ) u = radiceTrie; FOR (i = 0; i < m; i = i+1) { IF (u.figlio[ P[i] ] != nuli) { u = u.figlio[ P[i] ]; > ELSE

{

RETURN nuli;

> > RETURN

Codice 5.14

u.dato;

Algoritmo di ricerca in un trie.

Ogni stringa in S corrisponde a un nodo u del trie ed è quindi memorizzata nel campo u . d a t o . c h i a v e (e gli eventuali dati satellite sono in u . d a t o . s a t ) : per esempio, la foglia 5 corrisponde a Vercelli come mostrato in Figura 5.5, dove le foglie del trie sono numerate da 0 a 6, e la foglia numero i memorizza il nome della ( i + 1 )-esima provincia (0 ^ i ^ 6). In generale, estendendo tutte le stringhe con un simbolo speciale, da appendere in fondo a esse come terminatore di stringa, e memorizzando le stringhe così estese nel trie, otteniamo la proprietà che queste stringhe sono associate in modo univoco alle foglie del trie (quest'estensione non è necessaria se nessuna stringa in S è a sua volta prefisso di un'altra stringa in S). Notiamo che l'altezza di un trie è data dalla lunghezza massima tra le stringhe. Nel nostro esempio, l'altezza del trie è 9 in quanto la stringa più lunga nell'insieme è Catanzaro. Potando i sottoalberi che portano a una sola foglia, come mostrato nella parte destra della Figura 5.5, l'altezza media non dipende dalla lunghezza delle stringhe, ma è limitata superiormente da 2 l o g a n + 0 ( 1 ) , dove n è il numero di stringhe nell'insieme S. Tale potatura presume che le stringhe siano memorizzate altrove, per cui è possibile ricostruire il sottoalbero potato in quanto è un filamento di nodi contenente la sequenza di caratteri finali di una delle stringhe (alternativamente, tali caratteri possono essere memorizzati nella foglia ottenuta dalla potatura). Per quanto riguarda la dimensione del trie, indicando con N la lunghezza totale delle n stringhe memorizzate in S, ovvero la somma delle loro lunghezze, abbiamo che la dimensione di un trie è al più N + 1. Tale valore viene raggiunto quando ciascuna stringa in S ha il primo carattere differente da quello delle altre, per cui il trie è composto da una radice e poi da |S| filamenti di nodi, ciascun filamento corrispondente a una stringa. Tuttavia, se si adotta la versione potata del trie, la dimensione al caso medio non dipende dalla lunghezza delle stringhe e vale all'inora l , 4 4 n .

RicercaPref issi ( radiceTrie, P ): (pre: P è una stringa di lunghezza m ) u = radiceTrie; fine = false; FOR (i = 0; Ifine kk i < M; i = i+1) { IF (u.figlioC P[i] ] != nuli) { u = u.figlio[ P[i] ]; > ELSE {

fine = true;

> > numStringhe = 0; Recuperai u, elenco ); RETURN elenco;

Recuperai u, elenco ): IF (u != nuli) { IF (u.dato != nuli) { elenco[numStringhe]= u.dato; numStringhe = numStringhe + 1 ;

> FOR (c = 0; c < sigma; c = c + 1) Recuperai u.figlio[c], elenco );

> Codice 5.15 Algoritmo di ricerca per prefissi in un trie (numStringlie è una variabile globale).

Come possiamo notare dall'esempio nella Figura 5.5, i nodi del trie rappresentato prefissi delle stringhe memorizzate, e le stringhe che sono memorizzate nei nodi discendenti da un nodo u hanno in comune il prefisso associato a u . Nel nostro esempio, le foglie discendenti dal nodo che memorizza il prefisso p i hanno associate le stringhe pisa e pistoia. Sfruttiamo questa proprietà per implementare in modo semplice la ricerca di una stringa di lunghezza m in un trie utilizzando la sua definizione ricorsiva, come mostrato nel Codice 5.14: partiamo dalla radice per decidere quale figlio scegliere a livello i = 0 e, al generico passo in cui dobbiamo scegliere un figlio a livello i del nodo corrente u, esaminiamo il carattere P[i] della stringa da cercare. Osserviamo che, se il corrispondente figlio non è vuoto, continuiamo la ricerca portando il livello a i + 1. Se invece tale figlio è vuoto, possiamo concludere che P non è memorizzata nel dizionario. Quando i = m, abbiamo esaminato tutta la stringa P con successo pervenendo al nodo u di cui restituiamo l'elemento contenuto nel campo u . d a t o : in tal caso, osserviamo che P è memorizzato nel dizionario se e solo se tale campo è diverso da n u l i .

La parte interessante della ricerca mostrata nel Codice 5.14 è che, a differenza della ricerca mostrata per le tabelle hash e per gli alberi di ricerca, essa può facilmente identificare il nodo u che corrisponde al più lungo prefisso di P che appare nel trie: a tal fine, possiamo modificare la riga 7 del codice in modo che restituisca il nodo u (al posto di nuli). Di conseguenza, tutte le stringhe in S, che hanno tale prefisso di P come loro prefisso, possono essere recuperate nei nodi che discendono da u (incluso) attraverso una semplice visita, ottenendo il Codice 5.15: notiamo che le ricerche di stringhe lunghe, quando queste ultime non compaiono nel dizionario, sono generalmente più veloci delle corrispondenti ricerche nei dizionari implementati con le tabelle hash, poiché la ricerca nei trie si ferma non appena trova un prefisso di P che non occorre nel trie mentre la funzione hash è comunque calcolata sull'intera stringa prima di effettuare la ricerca. Non è difficile analizzare il costo della ricerca, in quanto vengono visitati O(m) nodi: poiché ogni nodo richiede tempo costante, abbiamo O(m) tempo di ricerca. Diamo un piccolo esempio quantitativo sulla velocità di ricerca dei trie, supponendo di volere memorizzare i codici fiscali in un trie: ricordiamo che un codice fiscale contiene 9 lettere prese dall'alfabeto A . . . Z di 26 caratteri, e 7 cifre prese dall'alfabeto 0 . . . 9 di 10 caratteri, per un totale di 26 9 x IO7 possibili codici fiscali. Cercare un codice fiscale in un trie richiede di attraversare al più 16 nodi, indipendentemente dal numero di codici fiscali memorizzati nel trie, in quanto l'altezza del trie è 16. In contrasto, la ricerca binaria o quella in un albero AVL, per esempio, avrebbe una dipendenza dal numero di chiavi: nel caso estremo, memorizzando metà dei possibili codici fiscali in un array ordinato, tale ricerca richiederebbe circa log(26 9 x IO7) — 1 ^ 6 4 confronti tra chiavi. Il trie è quindi una struttura di dati molto efficiente per la ricerca di sequenze. L'inserimento di un nuovo elemento nel dizionario rappresentato con un trie segue nuovamente la sua definizione ricorsiva, come mostrato nel Codice 5.16: se il trie è vuoto viene creata una radice (righe 2-7) e, quindi, dopo aver verificato che la chiave dell'elemento non appaia nel dizionario (riga 8), il trie viene attraversato fino a trovare un figlio vuoto in cui inserire ricorsivamente il trie per il resto dei caratteri (righe 14—18) oppure il nodo esiste già ma l'elemento da inserire deve essergli associato (riga 21). In altre parole, l'inserimento della stringa P cerca prima il suo più lungo prefisso x che occorre in un nodo u del trie, analogamente alla procedura R i c e r c a , e scompone P come xy: se y non è vuoto sostituisce il sottoalbero vuoto raggiunto con la ricerca di x, mettendo al suo posto il trie per y; altrimenti, semplicemente associa P al nodo u identificato. Il costo dell'inserimento è O(m) tempo in accordo a quanto discusso per la ricerca (e la cancellazione può essere trattata in modo analogo): da notare che non occorrono operazioni di ribilanciamento (rotazioni o divisioni) come succede negli alberi di ricerca. Infatti, un'importante proprietà è che la forma del trie è determinata univocamente dalle

Inserisci ( radiceTrie, e ): IF (radiceTrie == nuli) { radiceTrie = NuovoNodo( ); radiceTrie.dato = nuli; FOR (c < 0; c < sigma; c = c + 1) radiceTrie.figlio[c] = nuli;

(pre: e. chiave ha lunghezza m)

> IF (Ricercai radiceTrie, e.chiave ) == nuli) { u = radiceTrie; FOR (i = 0; i < m; i = i+1) { IF (u.figlio[ e.chiave[i] ] != nuli) { u = u.figlio[ e.chiave[i] ]; > ELSE {

u.figlioli e.chiave[i] ] = NuovoNodo( ); u = u.figlio[ e.chiave[i] ]; u.dato = nuli; FOR (C < 0; C < sigma; C = C + 1) u.figlio[c] = nuli;

}

> u.dato = e;

> RETURN

radiceTrie;

Codice 5.16 Algoritmo di inserimento di un elemento in un trie.

stringhe in esso contenute e non dal loro ordine di inserimento (contrariamente agli alberi di ricerca). ALVIE:

ricerca e i n s e r i m e n t o in u n trie

Osserva, s p e r i m e n t a e verifica

Trie

•O-O'O-O-O'O' • O •O 'o• • -o • o • •

Inoltre, poiché i trie preservano l'ordine lessicografico delle stringhe in esso contenute, possiamo fornire un semplice metodo per ordinare un array S di stringhe come mostrato nel Codice 5.17, in cui adoperiamo la funzione R e c u p e r a del Codice 5.15 per effettuare una visita simmetrica del trie costruito attraverso l'inserimento iterativo delle stringhe contenute nell'array S.

OrdinaLessicograf icamente( S ) : (pre: S è un array din stringhe) radiceTrie = nuli; elemento.sat = nuli; FOR (i = 0; i < n; i = i+1) { elemento.chiave = S[i]; radiceTrie = Inserisci( radiceTrie, elemento );

> numStringhe = 0; Recuperai radiceTrie, S ); RETURN

Codice 5.17

S;

Algoritmo di ordinamento di stringhe (fa uso di una variabile globale numStringhe).

La complessità dell'ordinamento proposto nel Codice 5.17 è O(N) tempo se la somma delle lunghezze delle n stringhe in S è pari a N. Un algoritmo ottimo per confronti, come il mergesort, impiegherebbe O ( n l o g n ) confronti, dove però ciascun confronto richiederebbe di accedere mediamente a N / n caratteri di una stringa, per un totale di O ( ^ - n l o g n ) = 0 ( N logn) tempo: l'ordinamento di stringhe con un trie è quindi più efficiente in tal caso (radixsort). Analogamente a quanto discusso per la ricerca in tabelle hash, il limite così ottenuto non contraddice il limite inferiore (in questo caso sull'ordinameno) poiché i caratteri negli elementi da ordinare sono utilizzati per altre operazioni oltre ai confronti. ALVIE:

ordinamento in un trie

_Osserva, . „ sperimenta e verifica

TrieSort

»-o o - •

Nati per ricerche come quelle discusse finora, i trie sono talmente flessibili da risultare utili per altri tipi di ricerche più complesse. Inoltre, sono utilizzati nella compressione dei dati, nei compilatori e negli analizzatori sintattici. Servono a completare termini specificati solo in parte; per esempio, i comandi nella shell, le parole nella composizione dei testi, i numeri telefonici e i messaggi SMS nei telefoni cellulari, gli indirizzi del Web o della posta elettronica. Permettono la realizzazione efficiente di correttori ortografici, di analizzatori di linguaggio naturale e di sistemi per il recupero di informazioni mediante basi di conoscenza. Forniscono operazioni di ricerca più complesse di quella per prefissi, come la ricerca con espressioni regolari e con errori. Permettono di individuare ripetizioni nelle stringhe (utili, per esempio, nell'analisi degli stili di scrittura di vari autori) e

di recuperare le stringhe comprese in un certo intervallo. Le loro prestazioni ne hanno favorito l'impiego anche nel trattamento di dati multidimensionali, nell'elaborazione dei segnali e nelle telecomunicazioni. Per esempio sono utilmente impiegati nella codifica e decodifica dei messaggi, nella risoluzione dei conflitti nell'accesso ai canali e nell'istradamento veloce dei router in Internet. A fronte della loro duttilità, i trie hanno una struttura sorprendemente semplice. Purtroppo essi presentano alcuni svantaggi dal punto di vista dello spazio occupato per alfabeti grandi, in quanto ciascuno dei loro nodi richiede l'allocazione di un array di ff elementi: inoltre, le loro prestazioni possono peggiorare se il linguaggio di programmazione adottato non rende disponibile un accesso efficiente ai singoli caratteri delle stringhe. Esistono diverse alternative per l'effettiva rappresentazione in memoria di un trie che sono basate sulla rappresentazioni dei suoi nodi mediante strutture di dati alternative agli array come le liste, le tabelle hash e gli alberi binari.

5.6.2

Trie compatti e alberi dei suffissi

I trie discussi finora hanno una certa ridondanza nel numero dei nodi, in quanto quelli con un solo figlio non vuoto rappresentano una scelta obbligata e non raffinano ulteriormente la ricerca nei trie, al contrario dei nodi che hanno due o più figli non vuoti. Tale ridondanza è rimossa nel trie compatto, mostrato nella parte sinistra della Figura 5.6, dove i nodi con un solo figlio non vuoto sono altrimenti rappresentati per preservare le funzionalità del trie: a tal fine, gli archi sono etichettati utilizzando le sottostringhe delle chiavi appartenenti agli elementi dell'insieme S, invece che i loro singoli caratteri. Formalmente, dato il trie per le chiavi contenute negli elementi dell'insieme S, classifichiamo un nodo del trie come unario se ha esattamente un figlio non vuoto. Una catena di nodi unari è una sequenza massimale u o , u i , . . . , u r _ i di r ^ 2 nodi nel trie tale che ciascun nodo Ut è unario per 1 ^ i ^ r — 2 (notiamo che Uo potrebbe essere la radice oppure u r _ i potrebbe essere una foglia). Sia Ci il carattere per cui Ui = Ui_i.f i g l i o [ c i ] e (3 = C] • • • c r _ i la sottostringa ottenuta dalla concatenazione dei caratteri incontrati percorrendo la catena da ito a u r _ i : definiamo l'operazione di compattazione della catena sostituendo l'intera catena con la coppia di nodi uo e u r _ j collegati da un singolo arco (uo,u T _i ), che è concettualmente etichettato con |3. Notiamo infatti che l'esplicita memorizzazione di (3 non è necessaria se associamo, a ciascun nodo u, il prefisso ottenuto percorrendo il cammino dalla radice fino a u (la radice ha quindi un prefisso vuoto): in tal modo, indicando con a il prefisso nel padre di u e con y quello in u, possiamo ricavare 3 per differenza in quanto a(3 = y e la sottostringa |3 è data dagli ultimi r — 1 = ||3| caratteri di y. Il trie compatto per l'insieme S è ottenuto dal trie costruito su S applicando l'operazione di compattazione a tutte le catene presenti nel trie stesso. Ne risulta che i nodi del trie compatto sono foglie oppure hanno almeno due figli non vuoti. Per implementare

Figura 5.6

A sinistra, il trie compatto per memorizzare i nomi di alcune province; a destra, la versione con le sottostringhe rappresentate mediante triple.

un trie compatto, estendiamo l'approccio adottato per i trie, utilizzando la rappresentazione degli alberi cardinali cr-ari (Paragrafo 4.4): ciascun nodo u di un trie compatto è dotato di un campo u . d a t o in cui memorizzare un elemento e s S (quindi i campi di e sono indicati come u . d a t o . c h i a v e e u . d a t o . s a t ) a cui aggiungiamo un campo u . p r e f i s s o per memorizzare il prefisso associato a u . Tale prefisso è memorizzato mediante una coppia (e, j) per indicare che esso è dato dai primi j caratteri della stringa contenuta nel campo e . c h i a v e : il vantaggio è che rappresentiamo ciascun prefisso con soli due interi indipendentemente dalla lunghezza del prefisso stesso, perché lo spazio richiesto da ciascun nodo rimane O(a) (purché i campi chiave degli elementi siano memorizzati a parte). La parte destra della Figura 5.6 mostra un esempio di tale rappresentazione, dove possiamo osservare che un nodo interno u appare nel trie compatto se e solo se, prendendo il prefisso a associato a u, esistono almeno due caratteri c / c' dell'alfabeto L tali che entrambi ac e a c ' sono prefissi delle chiavi di alcuni elementi in S. La presenza di due chiavi, una prefisso dell'altra, potrebbe introdurre nodi unari che non possiamo rimuovere. Per tale ragione, estendiamo tutte le chiavi degli elementi in S con un ulteriore carattere $, che è un simbolo speciale da usare come terminatore di stringa (analogamente al carattere ' \ 0 ' nel linguaggio C). In tal modo, poiché $ appare solo in fondo alle stringhe, nessuna può essere prefisso dell'altra e, come osservato in precedenza, esiste una corrispondenza biunivoca tra le n chiavi e le n foglie del trie compatto costruito su di esse: quindi, presumiamo che ciascuna delle n foglie contenga un distinto elemento e € S (in particolare, illustriamo questa corrispondenza nella Figura 5.6 etichettando con i la foglia contenente ti). Utilizzando il simbolo speciale e la rappresentazione dei prefissi mediante coppie, il trie compatto ha al più n nodi interni e

RicercaPref issi( radiceTrieCompatto, P ): u = radiceTrieCompatto; fine = false; i = 0; WHILE (¡fine kk

{pre: P contiene m caratteri)

i < M) {

IF (u.figlioli P[i] ] != nuli) { u = u.figliot P[i] ]; = u.prefisso; WHILE (Ci < m ) kk

(i < j) kk

(P[i] == e.chiave[i]))

i = i + 1; fine = (i < m) kk (i < j); } ELSE {

fine = true;

> > numStringhe = 0; Recuperai u, elenco ); Codice 5.18

Algoritmo di ricerca per prefissi in un trie compatto (fa uso di una variabile globale numStringhe e della funzione Recupera del Codice 5.15).

n foglie, e quindi richiede O ( n a ) spazio, dove a = 0 ( 1 ) per le nostre ipotesi: lo spazio dipende quindi solo dal numero n delle stringhe nel caso pessimo e non dalla somma N delle loro lunghezze, contrariamente al trie. La rappresentazione compatta di un trie non ne pregiudica le caratteristiche discusse finora. Per esempio la ricerca per prefissi in un trie compatto simula quella per prefissi in un trie (Codice 5.15) ed è mostrata nel Codice 5.18: la differenza risiede nelle righe 8 11 dove, dopo aver raggiunto il nodo u , ne prendiamo il prefisso a esso associato e ne confrontiamo i caratteri con P, dalla posizione i in poi, fino alla fine di una delle due stringhe oppure quando troviamo due caratteri differenti (riga 9). Analogamente alla ricerca nei trie, terminiamo di effettuare confronti quando tutti caratteri di P sono stati esaminati con successo oppure troviamo il suo più lungo prefisso che occorre nel trie compatto, e il costo del Codice 5.18 rimane pari a 0 ( m ) tempo più il numero di occorrenze riportate. L'operazione R i c e r c a è realizzata in modo analogo a quella per prefissi e mantiene la complessità di 0 ( m ) tempo. Analogamente alla ricerca, l'inserimento di un nuovo elemento e nel trie compatto richiede 0 ( m ) tempo come mostrato nel Codice 5.19. Dopo aver creato la radice (righe 2-8), se necessario, a cui associamo il prefisso vuoto (di lunghezza 0), verifichiamo che l'elemento non sia già nel dizionario. A questo punto, procediamo come nel caso della ricerca per prefissi per identificare il più lungo prefisso x della chiave di e che oc-

Inserisci( radiceTrieCompatto, e ): (pire: e. chiave ha lunghezza m ) IF (radiceCompattoTrie == nuli) { radiceTrieCompatto = NuovoNodo( ); radiceTrieCompatto.prefisso = ; radiceTrieCompatto.dato = nuli; FOR (c < 0; c < sigma; c = c + 1) radiceTrieCompatto.figlio[c] = nuli;

> IF (Ricercai radiceTrieCompatto, e.chiave ) == nuli) { u = radiceTrieCompatto; fine = false; i = 0; WHILE (Ifine Sete i < m) { v = u; indice = i; IF (u.figlio[ e.chiave[i] ] != nuli) { u = u.figlio[ e.chiave[i] ]; = u.prefisso; WHILE (i < M & & i < j && p.chiave[i] == e.chiave[i])

i = i + 1; fine = (i < m) && (i < j) ; > ELSE {

fine = true;

> > IF (fine) CreaFoglia( v, u, indice, i );

> RETURN

radiceTrieCompatto;

Codice 5.19 Algoritmo per l'inserimento di un elemento in trie compatto.

corre nel trie compatto, dove P = xy. Sia u il nodo raggiunto e v il nodo calcolato nelle righe 11-23 e sia i = |x|: se x coincide con il prefisso associato a u, allora v = u; se invece, x è più breve del prefisso associato a u , allora v è il padre di u . Invochiamo ora C r e a F o g l i a , descritta nel Codice 5.20, che fa la seguente cosa: se u ^ v, spezza l'arco (u,v) in due creando un nodo intermedio a cui associa x come prefisso (corrispondente ai primi i caratteri di e . c h i a v e ) e a cui aggancia la nuova foglia che memorizza l'elemento e, la cui chiave ne diventa il prefisso di lunghezza m (in quanto prendiamo tutti i caratteri di e . c h i a v e ) ; se invece u = v, crea soltanto la nuova foglia come descritto sopra, agganciandola però a u. Ricordiamo che, non essendoci una chiave prefisso di un'altra, ogni inserimento di un nuovo elemento crea sicuramente una foglia. Infine, la cancellazione dell'elemento avente chiave uguale a P, specificata in ingresso, richiede la rimozione della foglia raggiunta con la ricerca di P, nonché dell'arco che

CreaFoglia ( v, u, indice, i ) : (pre: e.chiave ha lunghezza m) IF (v != u) { v.figlio[ e.chiave[indice] ] = NuovoNodo( ); v = v.figlio[ e.chiave[indice] ]; v.prefisso = ; v.dato = nuli; FOR (C < 0; C < sigma; C = C + 1) v.figlio[c] = nuli; = u.prefisso; v.figlio[ p.chiave[i] ] = u; u = v;

> u.figlio[ e.chiave[i] ] = NuovoNodo( ); u = u.figliof e.chiavefi] ]; u.prefisso = ; u.dato = e; FOR (c < 0; c < sigma; c = c + 1) u.figlio[c] = nuli; Codice 5.20

Algoritmo per la creazione di una foglia e di un eventuale nodo (suo padre).

collega la foglia a suo padre u . Se u diventa unario, allora dobbiamo rimuovere u , il suo arco entrante e il suo arco uscente, sostituendoli con un unico arco la cui etichetta è la concatenazione della sottostringa nell'arco entrante con quella nell'arco uscente. Tuttavia dobbiamo stare attenti a non usare elementi cancellati per i prefissi associati ai nodi u del trie compatto: se e viene cancellato e un antenato u della corrispondente foglia contiene il prefisso (e, j), allora è sufficiente individuare un altro elemento e' contenuto in una foglia che discende da u e sostituire quel prefisso con (e', j). Il costo della cancellazione è O(m) poiché a = 0 ( 1 ) . ALVIE:

trie compatto Osserva, sperimenta e verifica CompactTrie

Uno dei motivi per introdurre le complicazioni della gestione dei trie compatti, rispetto a quella più semplice dei trie, è il loro utilizzo per una struttura di dati con un numero sempre crescente di applicazioni. Dato un testo T di n caratteri in cui l'ultimo

Figura 5.7

Albero dei suffissi per T = banana$.

carattere è il simbolo speciale $, definiamo il suo suffisso i come il segmento composto dagli ultimi caratteri T[i, n — 1], per 0 ^ i ^ n — 1. Un albero dei suffissi ( s u f f i x tree) per T è il trie compatto costruito su n chiavi, che sono tutti i suffissi i di T per 0 ^ i ^ n — 1. Un esempio dell'albero dei suffissi per il testo T = b a n a n a $ è mostrato nella Figura 5.7, come risulta dalla costruzione del trie compatto sulle seguenti chiavi (che sono i suffissi di T numerati da 0 a 6): 0. b a n a n a $

1. anaiia$

2. n a n a $

3. a n a $

4. n a $

5. a$

6.$

Gli alberi dei suffissi vengono studiati per la loro importanza nella costruzione di indici testuali che risultano più potenti delle liste invertite: infatti, l'utilizzo degli alberi dei suffissi non necessita di dividere il testo in segmenti che rappresentano i termini ma, piuttosto, ognuno dei (2) = 0 ( n 2 ) segmenti del testo è un potenziale termine di ricerca, come succede nelle sequenze biologiche. Il vantaggio di impiegare un albero dei suffissi, essendo un trie compatto con n foglie, è che lo spazio occupato è lineare a fronte di un numero 0 ( n 2 ) di potenziali termini: è chiaro che memorizzando tali termini nel vocabolario V delle liste invertite avremmo spazio quadratico o superiore, mentre con l'albero dei suffissi tale spazio è soltanto di O(n) celle di memoria incluse quelle necessarie a memorizzare T. Notiamo che, applicando l'inserimento descritto nel Codice 5.19 ai vari suffissi, possiamo costruire l'albero dei suffissi per T in tempo Lr=o |T[i,n - 1]| = Lr=O' (T-L — i) = 0 ( n 2 ) (otteniamo tale costo quando, ad esempio, i primi n — 1 caratteri di T sono tutti uguali): esistono vari algoritmi che permettono la costruzione di tale struttura di dati richiedendo soltanto O(n) tempo. L'impiego degli alberi dei suffissi nella costruzione degli indici per documenti, si basa sulla seguente proprietà fondamentale delle occorrenze: un termine P di m caratteri

occorre in posizione i del testo T (ovvero P = T[i, i — m + 1]) se e solo se P è prefisso del suffisso T[i, n — 1]. In altre parole, il problema della ricerca in un testo {pattern matching) può essere formulato in termini della ricerca per prefissi descritta nel Codice 5.18. Tale ricerca non è applicata a stringhe indipendenti, bensì ai suffissi del testo come abbiamo mostrato sopra: una volta individuato il nodo u che corrisponde a P, le foglie i discendenti da u corrispondono esattamente alle posizioni i del testo in cui P occorre. Per esempio, nella Figura 5.7, la ricerca di P = a n a conduce al nodo le cui foglie discendenti sono i = 1 e i = 3, che sono anche le occorrenze di P. La proprietà fondamentale riduce quindi il problema di cercare P in T al problema di cercare P nel trie compatto e, quindi, il costo della ricerca è indipendente dalla lunghezza del testo, ovvero è O(m) più il numero di occorrenze trovate (osserviamo che la proprietà fondamentale vale non solo per la ricerca esatta, ma anche per altri tipi di ricerca che utilizzano l'albero dei suffissi). Volendo utilizzare l'albero dei suffissi per una collezione di documenti D = {To,Ti,..., T s _i}, basta che lo costruiamo sul testo T = To$Ti$ • • • $T s _i$ ottenuto concatenando i testi in D separati dal simbolo speciale $: poiché P non contiene tale simbolo, le sue occorrenze sono esclusivamente all'interno di ciascun documento. Concludiamo il paragrafo discutendo alcune tra le molteplici applicazioni dell'albero dei suffissi che dimostra avere "una miriade di virtù" (alcuni studi recenti mostrano come ridurre ulteriormente lo spazio richiesto dagli alberi dei suffissi per renderlo paragonabile a quello richiesto dalle liste invertite). Una prima applicazione è quella di memorizzare, in modo compatto, la statistica sulle sottostringhe. Prima dell'invenzione dell'albero dei suffissi, alcuni problemi erano ritenuti difficili: un esempio è dato dal trovare, in tempo O(n), la più lunga sottostringa che appare in T almeno due volte. La soluzione diventa semplice con l'utilizzo del suddetto albero, in quanto tale sottostringa corrisponde a uno dei prefissi più lunghi memorizzati in un nodo interno dell'albero. Una seconda applicazione è nella compressione dei dati con i metodi basati su dizionario, come l'algoritmo di sostituzione testuale Lempel-Ziv su cui si basa il compressore g z i p , oppure con i metodi basati sull'ordinamento, come l'algoritmo della trasformata di Burrows-Wheeler su cui si basa il compressore b z i p . In quest'ultimo caso, dobbiamo ordinare lessicograficamente i suffissi del testo e questo ordinamento è facilmente reperibile eseguendo una visita simmetrica nell'albero dei suffissi (analoga al Codice 5.17). Un'ulteriore applicazione è nella ricerca approssimata di stringhe, in cui è rilevante l'uso di una primitiva l c p ( i , j) che restituisce il massimo numero di caratteri iniziali uguali tra i due suffissi T[i,n — 1] e T[j,n — 1], per 0 ^ i,) < n , in tempo costante. Dopo aver applicato l'algoritmo del minimo antenato comune (Paragrafo 4.2) all'albero dei suffissi, ogni volta che perviene un'interrogazione l c p ( i , j), possiamo restituire il valore richiesto in tempo costante prendendo le foglie i e j nell'albero dei suffissi, indi-

viduando il loro minimo antenato comune u. e restituendo la seconda componente di u . p r e f i s s o , che rappresenta la lunghezza del prefisso corrispondente a u. RIEPILOGO In questo capitolo abbiamo descritto come realizzare un dizionario utilizzando le tabelle hash, gli alberi di ricerca, gli alberi AVL, i B-alberi e, infine, i trie o alberi digitali di ricerca, inclusi gli alberi dei suffissi e le liste invertite, discutendo la complessità di ciascuna realizzazione. ESERCIZI 1. Mostrate come estendere i dizionari discussi nel capitolo in modo che possano gestire multi-insiemi con chiavi eventualmente ripetute. 2. Valutate il costo della rappresentazione dei grafi con liste di adiacenza realizzate mediante dizionari. 3. Descrivete la cancellazione fisica da tabelle hash a indirizzamento aperto. 4. Dimostrate per induzione su h. che rin = Fk+3 — 1 negli alberi di Fibonacci. 5. Mostrate che la complessità dell'inserimento in un AVL cambia significativamente se sostituiamo la funzione A l t e z z a del Codice 5.7 con quella ricorsiva definita nel Capitolo 4. 6. Mostrate che, dopo aver ribilanciato tramite le rotazioni un nodo critico a seguito di un inserimento, non ci sono altri nodi critici. 7. Mostrate che, analogamente a quanto fatto per la ricerca binaria, D(Iog B n) è il limite inferiore per il numero di trasferimenti necessari nella ricerca di chiavi per confronti (ogni nuovo blocco caricato in memoria principale aumenta le possibili scelte di una fattore almeno pari a B/2). 8. Supponendo che la lista di nodi su ciascun livello del B-albero sia bidirezionale e utilizzando il B-albero in memoria principale con B = 4 e i puntatori ai padri, descrivete un algoritmo di ricerca chiamato finger search, il cui costo è O(logd) tempo dove d < n è il numero di chiavi che intercorrono nella lista delle foglie tra la chiave attualmente cercata k e l'ultima chiave cercata k' (mantenete un riferimento chiamato finger a k', aggiornandolo con ogni ricerca). 9. Mostrate come gestire il campo u . p a d r e negli alberi binari di ricerca, negli alberi AVL e nei B-alberi (in questi ultimi, l'inserimento può richiedere 0(B log B n) trasferimenti ma il costo ammortizzato diventa 0(log B n) utilizzando il riferimento alla lista dei nodi sullo stesso livello).

10. Discutete come realizzare, per i dizionari ordinati, le operazioni S u c c e s s o r e , P r e d e c e s s o r e , I n t e r v a l l o e Rango descritte nel Paragrafo 5.1, utilizzando gli alberi AVL, i B-alberi e i trie, analizzandone la complessità. 11. Un'occorrenza della stringa P nella posizione i del testo T ha al più k mismatch se il numero di posizioni in cui i caratteri di P e T[i, i + m— 1] differiscono è al più k, dove m è la lunghezza di P e k ^ m. Utilizzando la primitiva l c p , mostrate come trovare tutte le occorrenze di P in T con al più k mismatch in tempo O(nk), dove n è la lunghezza di T.

Capitolo 6

Grafi

SOMMARIO In questo capitolo esaminiamo le caratteristiche principali dei grafi, fornendo le definizioni relative a tali strutture. Mostriamo come attraverso di essi sia possibile modellare una quantità di situazioni e come molti problemi possano essere interpretati come problemi su grafi. Introduciamo poi il paradigma dell'algoritmo goloso applicandolo alla risoluzione del problema della colorazione e di quello del massimo insieme indipendente nel caso di grafi a intervalli. Infine, studiamo il concetto di rete complessa e mostriamo come sia possibile sfruttare la struttura a grafo del World Wide Web per rendere più efficaci le ricerche di documenti in esso contenuti. DIFFICOLTÀ I CFU

6.1

Grafi

II collegamento tra due nodi nelle liste rappresenta la relazione tra predecessore e successore, mentre il collegamento negli alberi rappresenta la relazione tra figlio e padre. I collegamenti nei grafi rappresentano una generalizzazione di tali relazioni e includono, come caso particolare, la relazione espressa da liste e alberi: il collegamento tra due nodi in un grafo rappresenta una relazione di adiacenza o di vicinanza tra tali nodi. L'importanza dei grafi deriva dal fatto che una grande quantità di situazioni può essere modellata e rappresentata mediante essi, e quindi una grande quantità di problemi può essere espressa per mezzo di problemi su grafi: gli algoritmi efficienti su grafi rappresentano alcuni strumenti generali per la risoluzione di numerosi problemi di rilevanza pratica e teorica. Un grafo G è definito come una coppia di insiemi finiti G = (V, E), dove V rappresenta l'insieme dei nodi o vertici e le coppie di nodi in E C V x V sono chiamate archi o

Figura 6.1

Rotte areee di collegamento tra alcune capitali europee.

lati. Il numero n = |V| di nodi è detto ordine del grafo, mentre m = |E| indica il numero di archi (i due numeri possono essere estremamente variabili, l'uno rispetto all'altro). La dimensione del grafo è data dal numero n + m totale di nodi e di archi, per cui la dimensione dei dati in ingresso è espressa usando due parametri nel caso dei grafi, contrariamente al singolo parametro adottato per la dimensione di array, liste e alberi. Infatti, n e m vengono considerati parametri indipendenti, per cui nel caso di grafi la complessità lineare viene riferita al costo 0 ( n + m) di entrambi i parametri. In generale, vale 0 m ^ (2) poiché il numero massimo di archi è dato dal numero (2) = 0 ( n 2 ) di tutte le possibili coppie di nodi: il grafo è sparso se m = O(n) e denso se m = @(n 2 ). Nella trattazione di grafi un arco viene inteso come un collegamento tra due nodi u e v e viene rappresentato con la notazione (u, v) (che, come vedremo, è un piccolo abuso per semplificare la notazione del libro). Ciò è motivato dalla descrizione grafica utilizzata per rappresentare grafi, in cui i nodi sono elementi grafici (punti o cerchi) e

gli archi sono linee colleganti le relative coppie di nodi, questi ultimi detti terminali o estremi degli archi. Consideriamo l'esempio mostrato nella Figura 6.1, che riporta le rotte di una nota compagnia aerea relativamente all'insieme V degli aeroporti dislocati presso alcune capitali europee, identificate mediante il codice internazionale del corrispondente aeroporto: BVA (Parigi), CIA (Roma), CRL (Bruxelles), DUB (Dublino), MAD (Madrid), NYO (Stoccolma), STN (Londra), SXF (Berlino), TRF (Oslo). Possiamo rappresentare le rotte usando una forma tabellare come quella riportata in basso nella Figura 6.2, in cui la casella all'incrocio tra la riga x e la colonna y contiene il tempo di volo (in minuti) per la rotta che collega gli aeroporti x e y. La casella è vuota se non esiste una rotta aerea. Tale rappresentazione è mostrata graficamente mediante uno dei due grafi in alto nella Figura 6.2, dove ciascun arco (x,y) € E rappresenta la rotta tra x e y etichettata con il tempo di volo corrispondente (osserviamo che una lista lineare o un albero non riescono a modellare l'insieme delle rotte). Un grafo G = ( V, E) è detto pesato o etichettato sugli archi se è definita una funzione W : E i-> 1 che assegna un valore (reale) a ogni arco del grafo. Nell'esempio della Figura 6.2, i pesi sono dati dai tempi di volo. Nel seguito, con il termine grafo pesato G = (V, E, W) indicheremo un grafo pesato sugli archi. L'esempio mostrato nelle Figure 6.1 e 6.2 illustra una serie di nozioni sulla percorribilità e raggiungibilità dei nodi di un grafo. Dato un arco (u,v), diremo che i nodi u e v sono adiacenti e che l'arco (u, v) è incidente a ciascuno di essi: in altri termini, un arco (u,v) è incidente al nodo x se e solo se x = u oppure x = v. Il numero di archi incidenti a un nodo è detto grado del nodo e un nodo di grado 0 è detto isolato. Facendo riferimento al grafo nell'esempio, il nodo CIA ha grado pari a 5 mentre il nodo MAD è isolato. Una proprietà che viene spesso utilizzata è che la somma dei gradi dei nodi è pari a 2m (il doppio del numero di archi). Per mostrare ciò, dobbiamo vedere ciascun arco come incidente a due nodi, per cui la presenza di un arco fa aumentare di 1 il grado di entrambi i suoi due estremi: il contributo di ogni arco alla somma dei gradi è pari a 2. Invece di sommare i gradi di tutti i nodi, possiamo calcolare tale valore moltiplicando per 2 il numero m di archi. Nell'esempio, m = 12 e la somma dei gradi è 24. E naturale chiederci se, a partire da un nodo, è possibile raggiungere altri nodi attraversando gli archi: relativamente al nostro esempio, vogliamo sapere se è possibile andare da una città a un'altra prendendo uno o più voli. Tale percorso viene modellato nei grafi attraverso un cammino da un nodo u a un nodo z, definito come una sequenza di nodi x 0 , x i , x 2 , . . . , x ^ tale che xo = u, x^ = z e (xi,xi + i ) e E per ogni 0 ^ i < k: l'intero k ^ 0 è detto lunghezza del cammino. Un ciclo è un cammino per cui vale x 0 = x k , ovvero un cammino che ritorna nel nodo di partenza. Un cammino (o un

BVA 90 " 120

DUB-

120 130

CRLMAD

SXF

Figura 6.2

CRL -

MAD

-

-

-

110

95 -

>NYO

STN HO

SXF.

DUB -

STN 110

MAD

115

TRF

TRF

BVA

-

-

-

-

-

-

-

-

-

-

-

-

-

95

160

135

115

-

130

'CRL-

I35

TRF

SXF

140

95

STN 110

CIA

120

DUB-

* 175 -NY0 160

190 BVA 90 "

175 140

'90

95

SXF CRL DUB STN MAD TRF BVA CIA NY0

120

-

115

90 -

CIA -

120 190 160

NY0 -

130 -

135

-

-

-

-

-

120 130

-

90 190 -

115 -

160 135

-

-

-

-

-

-

-

-

-

-

120 140

-

120 -

175

-

140 175 -

Rappresentazione a grafo (con n = 9 nodi e m = 12 archi) e tabellare delle rotte mostrate nella Figura 6.1.

ciclo) è semplice se non attraversa alcun nodo più di una volta, ossia se non esiste alcun ciclo annidato al suo interno. Nella Figura 6.2 esiste un cammino semplice di lunghezza k = 3 da u = BVA a z = SXF, dato da BVA, NY0, STN, SXF. Il cammino BVA, CIA, DUB, CRL, CIA, NY0, STN, SXF non è semplice a causa del ciclo CIA, DUB, CRL, CIA. Invece, STN, TRF, SXF non è un cammino in quanto TRF e SXF non sono collegati da un arco. Un cammino minimo da u a z è caratterizzato dall'avere lunghezza minima tra tutti i possibili cammini da u. a z: in altre parole, vogliamo sapere qual è il modo di andare dalla città u alla città z usando il minor numero di voli. Nell'esempio, sia BVA, CIA, STN, SXF che BVA, NY0, STN, SXF sono cammini minimi. La distanza tra due nodi u e z è pari alla lunghezza di un cammino minimo che li congiunge e, se tale cammino non esiste, è pari a +oo: la distanza tra BVA e SXF è 3 mentre tra BVA e MAD è +oo.

190

CIA

190

BVA

BVA

90

' 90 . ' '' \

175 DUB

DUB

140

NYO

MAD

TRF

Figura 6.3

175 \

NfO

MAD

CIA 120

;

TRF

Un sottografo e un sottografo indotto del grafo a destra nella Figura 6.2.

Nel caso di grafi pesati ha senso definire il peso di un cammino come la somma dei pesi degli archi attraversati (che sono quindi intesi come "lunghezze" degli archi), ovvero come ^ J q W ( x i , x i + i ) : nel nostro esempio, ipotizzando che il tempo di commutazione tra un volo e il successivo sia nullo, vogliamo sapere qual è il modo più veloce per andare da una città a un'altra (a differenza del cammino minimo). Il cammino minimo pesato è il cammino di peso minimo tra due nodi e la distanza pesata è il suo peso (oppure +oo se non esiste alcun cammino tra i due nodi). Nel nostro esempio, il cammino minimo pesato è BVA, NYO, STN, SXF (e quindi la distanza pesata è 385) perché il cammino BVA, CIA, STN, SXF ha peso pari a 390 (non è detto che un cammino minimo pesato debba essere anche un cammino minimo). I cammini permettono di stabilire se i nodi del grafo sono raggiungibili: due nodi u e z sono detti connessi se esiste un cammino tra di essi. Nell'esempio i nodi BVA e SXF sono connessi, in quanto esiste il cammino BVA, NYO, STN, SXF che li congiunge, mentre i nodi BVA e MAD non lo sono. Un grafo in cui ogni coppia di nodi è connessa è detto a sua volta connesso. Dato un grafo G = (V, E), un sottografo di G è un grafo G' = (V', E') composto da un sottoinsieme dei nodi e degli archi presenti in G: ossia, V' C V ed E' C V' x V' e, inoltre, vale E' C E. Nella Figura 6.3 è mostrato a sinistra un sottografo del grafo presentato nella Figura 6.2. Se vale la condizione aggiuntiva che in E' appaiono tutti gli archi di E che connettono nodi di V', allora G' viene denominato sottografo indotto da V'. E sufficiente specificare solo V' in tal caso: il grafo mostrato a destra nella Figura 6.3 è il sottografo indotto dall'insieme di nodi V' = {BVA, CIA, DUB, NYO, MAD, TRF}. Possiamo quindi definire una componente connessa di un grafo G come un sottografo G' connesso e massimale di G, vale a dire un sottografo di G avente tutti nodi

Lungarno Fibonacci

V. Bruno Figura 6.4

Parte della rete stradale della città di Pisa, dove le strade a doppio senso di circolazione sono rappresentate mediante una coppia di archi aventi etichetta comune.

connessi tra loro e che non può essere esteso, in quanto non esistono ulteriori nodi in G che siano connessi ai nodi di G'. All'interno di una componente connessa possiamo raggiungere qualunque nodo della componente stessa, mentre non possiamo passare da una componente all'altra percorrendo gli archi del grafo: la richiesta di massimalità nelle componenti connesse è motivata dall'esigenza di determinare con precisione tutti i nodi raggiungibili. Facendo riferimento al grafo nella Figura 6.2, il sottografo indotto dai nodi STN, SXF, TRF è connesso, ma non è una componente connessa del grafo, in quanto può essere esteso, ad esempio, aggiungendo il nodo CIA. In effetti, il grafo in questione risulta composto da due componenti connesse: la prima indotta dal nodo isolato MAD e la seconda indotta dai restanti nodi. Come possiamo osservare, un grafo connesso è composto da una sola componente connessa.1 Un grafo completo o cricca (clique) è caratterizzato dall'avere tutti i suoi nodi a due a due adiacenti. Facendo riferimento al grafo nella Figura 6.2, il sottografo indotto dai nodi CIA, CRL, DUB è una cricca (anche se non è una componente connessa in quanto esistono altri nodi, come BVA, che sono collegati alla cricca). La notazione K r è usata per indicare una cricca di r vertici e, nel nostro grafo, compaiono diversi sottografi che sono K3 (ma nessun K4 vi appare). I grafi discussi finora sono detti non orientati in quanto un arco (u, v) non è distinguibile da un arco (v,u), per cui (u,v) = (v,u): entrambi rappresentanto simmetricamente un collegamento tra u e v. In diverse situazioni, tale simmetria è volutamente evitata, come nel grafo illustrato nella Figura 6.4, che rappresenta la viabilità stradale di alcuni punti nella città di Pisa, con i sensi unici indicati da singoli archi orientati e le strade a doppio senso di circolazione indicate da coppie di archi. Gli archi hanno un ' È interessante notare che un albero può essere equivalentemente visto come un grafo che è connesso e non contiene cicli, in cui un nodo viene designato come radice.

senso di percorrenza e la notazione (u, v) indica che l'arco va percorso dal nodo u. verso il nodo v, e quindi (u,v) ^ (v, u), in quanto il grafo è orientato o diretto. 2 L'arco (u, v) viene detto diretto da u a v, quindi uscente da u ed entrante in v. Il nodo u è denominato nodo iniziale o di partenza mentre v è denominato nodo finale, di arrivo o di destinazione. Il grado in uscita di un nodo è pari al numero di archi uscenti da esso, mentre il grado in ingresso è dato dal numero di archi entranti. Facendo riferimento al grafo nella Figura 6.4, il nodo B ha grado in ingresso pari a 4 e grado in uscita pari a 1, mentre il nodo C ha grado in ingresso pari a l e grado in uscita pari a 3. Il grado è la somma del grado d'ingresso e di quello d'uscita: in un grafo orientato la somma dei gradi dei nodi in uscita è uguale a m, poiché ciascun arco fornisce un contributo pari a 1 nella somma dei gradi in uscita. Inoltre, il numero di archi è 0 ^ m ^ 2 x (") poiché otteniamo il massimo numero di archi quando ci sono due archi diretti per ciascuna coppia di nodi. Nel seguito, sarà sempre chiaro dal contesto se il grafo sarà orientato o meno. Le definizioni viste finora per i grafi non orientati si adattano ai grafi orientati. Un cammino (orientato) da un nodo u a un nodo z soddisfa la condizione che tutti gli archi percorsi nella sequenza di nodi sono orientati da u a z. In questo caso, diciamo che il nodo u è connesso al nodo z (e questo non implica che z sia connesso a u perché la direzione è opposta). Allo stesso modo, possiamo definire un ciclo orientato come un cammino orientato da un nodo verso se stesso. Usando i pesi degli archi, la definizione di cammino minimo (pesato o non) e la nozione di distanza rimangono inalterate. La stessa cosa avviene per la definizione di sottografo. E importante evidenziare il concetto di grafo fortemente connesso, quando ogni coppia di nodi è connessa, e di componente fortemente connessa: quest'ultima va intesa come un sottografo massimale tale che, per ogni coppia di nodi u e z, in esso esistono due cammini orientati all'interno del sottografo, uno da u a z e l'altro da z a u. Nel grafo nella Figura 6.4, le due componenti fortemente connesse risultano dai sottografi indotti rispettivamente dai nodi A, B e da C, D, E, F, G. Nel presente e nei seguenti capitoli, discuteremo alcuni algoritmi che usano le nozioni introdotte finora, ipotizzando che i nodi siano numerati V = { 0 , 1 , . . . , n — 1}.

6.1.1

Alcuni problemi su grafi

La versatilità dei grafi nel modellare molte situazioni, e i relativi problemi computazionali che ne derivano, sono ben illustrati da un esempio "giocattolo" in cui vogliamo organizzare una gita in montagna per n persone. 2 Nella teoria dei grafi, un arco che collega due nodi u e v di un grafo non orientato viene rappresentato come un insieme di due nodi {u, v), spesso abbreviato come uv, mentre se il grafo è orientato l'arco viene rappresentato con la coppia (u, v) (infatti, {u, v) = {v,u} mentre (u, v) ^ (v,u)). Con un piccolo abuso di notazione, nel libro useremo (u, v) anche per gli archi non orientati, e in tal caso varrà (u, v) = (u, v), in quanto sarà sempre chiaro dal contesto se il grafo è orientato o meno.

Figura 6.5

Esempio di grafo delle conoscenze.

Per il viaggio, le poltrone nel pullman sono disposte a coppie e si vogliono assegnare le poltrone ai partecipanti in modo tale che due persone siano assegnate a una coppia di poltrone soltanto se si conoscono già (supponiamo che n sia un numero pari). Una tale situazione può essere modellata mediante un grafo G = (V, E) delle "conoscenze", in cui V corrisponde all'insieme degli n partecipanti ed E contiene l'arco (x,y) se e solo se le persone x e y si conoscono: nella Figura 6.5 è fornito un esempio di grafo di tale tipo. In questo modello, un assegnamento dei posti che soddisfi le condizioni richieste corrisponde a un sottoinsieme di archi E ' C E tale che tutti i nodi in V siano incidenti agli archi di E' (quindi tutti i partecipanti abbiano un compagno di viaggio) e ogni nodo in V compaia soltanto in un arco di E' (quindi ciascun partecipante abbia esattamente un compagno): tale sottoinsieme viene denominato abbinamento o accoppiamento perfetto {perfect matching) dei nodi di G. Nel caso del grafo mostrato nella Figura 6.5 esistono due abbinamenti diversi: il primo è {(v 0 ,vi), (v 2 ,v 4 ), (v 3 ,v 5 )}, mentre il secondo è {(v 0 ,v 4 ), (vi,v 2 ), (v 3 ,v 5 )}. Un problema simile lo abbiamo già incontrato nel caso dei matrimoni stabili discussi nel Capitolo 3: quest'ultimo può essere ora modellato come un abbinamento su un grafo bipartito G = (Vo, Vi,E), caratterizzato dal fatto di avere due insiemi di vertici Vo e Vj (i clienti e le clienti nel nostro caso) tali che ogni arco (x,y) e E ha gli estremi in insiemi diversi, quindi x 6 Vo,y G Vi oppure x € Vi,y e VoTornando alla gita, supponiamo che sia prevista un'escursione in quota per cui i partecipanti devono procedere in fila indiana lungo vari tratti del percorso. Ancora una volta, i partecipanti preferiscono che ognuno conosca sia chi lo precede che chi lo segue. In tal caso, si cerca un cammino hamiltoniano (dal nome del matematico del XIX secolo William Rowan Hamilton) ovvero un cammino che passi attraverso tutti i nodi una e una sola volta: si tratta quindi di trovare una permutazione ( 7 t o , 7 t i , . . . , 7 t _ i ) dei nodi che sia un cammino, ovvero (7ii,7ti + i) € E per ogni 0 ^ i ^ n — 2. Nel n

Figura 6.6

La città di Königsberg (immagine proveniente da w w v . w i k i p e d i a . o r g ) con evidenziati i ponti rappresentati da Euler come archi di un multigrafo che viene trasformato in un grafo non orientato.

grafo considerato esistono quattro cammini hamiltoniani diversi, dati dalle sequenze (V3,V5,V0,V1,V2,V4), (V3,V5,Vo,Vi,V4,V2), (v3,V5,Vo,V4,V2,Vi) e (V3,V5,V0,V4,V1,V2).3

Consideriamo quindi il caso in cui, giunti al ristorante del rifugio montano, vogliamo disporre i partecipanti intorno a un tavolo in modo tale che ognuno conosca i suoi vicini, di destra e di sinistra. Quel che vogliamo, ora, è un cammino hamiltoniano nel grafo delle conoscenze in cui valga l'ulteriore condizione (7t n _i,7to) € E: tale ordinamento prende il nome di ciclo hamiltoniano. A differenza del caso precedente, possiamo notare come una permutazione di tale tipo non esista per il grafo considerato nell'esempio. Infine, tornati a valle, i partecipanti visitano un parco naturale ricco di torrenti che formano una serie di isole collegate da ponti di legno. I partecipanti vogliono sapere se è possibile effettuare un giro del parco attraversando tutti i ponti una e una sola volta, tornando al punto di partenza della gita. Il problema non è nuovo e, infatti, il principale matematico del XVIII secolo, Leonhard Euler, lo studiò relativamente ai ponti della città di Königsberg mostrati nella Figura 6.6, per cui l'origine della teoria dei grafi viene fatta risalire a Euler. Le zone delimitate dai fiumi sono i vertici di un grafo e gli archi sono i ponti da attraversare: nel caso che più ponti colleghino due stesse zone, ne risulta un multigrafo ovvero un grafo in cui la stessa coppia di vertici è collegata da archi multipli, come nel caso della Figura 6.6. In tal caso, sostituiamo ciascun arco multiplo (x,y) da una coppia di archi (x,w) e (w, z), dove w è un nuovo vertice usato soltanto per (x, y). In termini moderni, ne risulta un grafo G in cui vogliamo trovare un 3 In realtà, i cammini sarebbero otto, considerando quelli risultanti da un percorso "al contrario" dei quattro elencati.

ciclo euleriano, ovvero un ciclo (non necessariamente semplice) che attraversa tutti gli archi una e una sola volta (mentre un ciclo hamiltoniano attraversa tutti i nodi una e una sola volta). E possibile attraversare tutti i ponti come.richiesto se e solo se G ammette un ciclo euleriano: Euler dimostrò che la condizione necessaria e sufficiente perché ciò avvenga è che G sia connesso e i suoi nodi abbiano tutti grado pari, pertanto il grafo nella parte destra della Figura 6.6 non contiene un ciclo euleriano, in quanto presenta 4 nodi di grado dispari, mentre è fàcile verificare che K5 ammette un ciclo euleriano in quanto tutti i suoi nodi hanno grado 4. Euler dimostrò anche che se esattamente due nodi hanno grado dispari allora il grafo contiene un cammino euleriano, che comprende quindi ogni arco una e una sola volta: il grafo nella Figura 6.6 non contiene neanche un cammino euleriano. Come vedremo nei prossimi capitoli, la verifica che G sia connesso richiede tempo lineare, quindi il problema di Euler richiede 0 ( n + m) tempo e spazio. I problemi esaminati sinora derivano dalla modellazione di numerosi problemi reali, e sono stati studiati nell'ambito della teoria degli algoritmi. È interessante a tale proposito osservare che, pur avendo tali problemi una descrizione molto semplice, l'efficienza della loro soluzione è molto diversa: mentre per il problema dell'abbinamento e del ciclo euleriano sono noti algoritmi operanti in tempo polinomiale nella dimensione del grafo, per i problemi del cammino e del ciclo hamiltoniano non sono noti algoritmi polinomiali. Dato che è possibile verificare in tempo polinomiale se un cammino o un ciclo passano una e una sola volta per tutti i nodi, e quindi se sono hamiltoniani, ne deriva che tali problemi appartengono alla classe NP, e in effetti è anche possibile dimostrarne la NP-completezza.

6.1.2

Rappresentazione di grafi

La rappresentazione utilizzata per un grafo è un aspetto rilevante per la gestione efficiente del grafo stesso, e viene realizzata secondo due modalità principali (di cui esistono varianti): le matrici di adiacenza e le liste di adiacenza. Dato un grafo G = (V, E), la matrice di adiacenza A di G è un array bidimensionale di n x n elementi in {0,1} tale che A[i][j] = 1 se e solo se (i, j) e E per 0 ^ i, j ^ n — 1. In altre parole, A[i][j] = 1 se esiste un arco tra il nodo i e il nodo j, mentre A[i][j] = 0 altrimenti. Nella Figura 6.7 è fornita, a titolo di esempio, la matrice di adiacenza del grafo non orientato mostrato nella Figura 6.2 in cui il nodo i è associato alla riga i e alla colonna i, dove 0 ^ i < n, così fornendo, in corrispondenza degli elementi con valore 1; l'elenco dei nodi adiacenti a tale nodo. Se consideriamo grafi non orientati, vale A[i][j] = A[j][i] per ogni O ^ i , j ^ n — 1, e quindi A è una matrice simmetrica. Volendo rappresentare un grafo pesato, possiamo associare alla matrice di adiacenza una matrice P dei pesi che rappresenta in forma tabellare la funzione W, come mostrato nella tabella in basso nella Figura 6.2 (talvolta le matrici A e P vengono combinate in un'unica matrice per occupare meno spazio).

SXF CRL DUB STN MAD TRF BVA CIA NYO Figura 6.7

SXF 0 0 0 1 0 0 0 0 0

CRL 0 0 1 0 0 0 0 1 1

DUB 0 1 0 0 0 0 1 1 0

STN 1 0 0 0 0 1 0 1 1

MAD TRF 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0

BVA 0 0 1 0 0 0 0 1 1

CIA 0 1 1 1 0 0 1 0 1

NYO 0 1 0 1 0 0 1 1 0

Matrice di adiacenza per il grafo nella Figura 6.2.

La rappresentazione di un grafo mediante matrice di adiacenza consente di verificare in tempo 0(1) l'esistenza di un arco tra due nodi ma, dato un nodo i, richiede tempo O(n) per scandire l'insieme dei nodi adiacenti, anche se tale insieme include un numero di nodi molto inferiore a n, come mostrato dalle seguenti istruzioni: FOR ( j = 0; j < n; j = IF (A[i] [ j ] ! = 0) { PRINT arco ( i , j ) ; PRINT peso P [ i ] [ j ]

j+1) {

d e l l ' a r c o , se p r e v i s t o ;

> > Per scandire efficientemente i vertici adiacenti, conviene utilizzare un array contenente n liste di adiacenza. In questa rappresentazione, a ogni nodo I del grafo è associata la lista dei nodi adiacenti, detta lista di adiacenza e indicata con l i s t a A d i a c e n z a [ i ] , che implementiamo come un dizionario a lista (Paragrafo 5.2) di lunghezza pari al grado del nodo. Se il nodo ha grado zero, la lista è vuota. Altrimenti, l i s t a A d i a c e n z a [ i ] è una lista doppia con un riferimento sia all'elemento iniziale che a quello finale della lista di adiacenza per il nodo i: ogni elemento x di tale lista corrisponde a un arco (i, j) incidente a i e il corrispettivo campo x . d a t o contiene l'altro estremo j. Per esempio, il grafo mostrato nella Figura 6.2 viene rappresentato mediante liste di adiacenza come illustrato nella Figura 6.8. Volendo rappresentare un grafo pesato, è sufficiente aggiungere un campo x . p e s o contenente il peso W(i, j) dell'arco (i, j). La scansione degli archi incidenti a un dato nodo i può essere effettuata mediante la scansione della corrispondente lista di adiacenza, in tempo pari al grado di i, come illustrato nelle istruzioni del seguente codice.

SXF

STO

CRL

DUB |

1 CIA |

1 NYO

DUB

CRL |

1 BVA |

1 CIA |

STO

SXF |

1 TRF |

1 CIA |

1 CIA |

1 NYO |

[ NYO

MAD TRF

STO

BVA

DUB |

CIA

CRL

DUB |

1 STN |

1 BVA |

NYO

CRL

STN |

1 BVA

CIA

Figura 6.8

1 NYO

Lista di adiacenza per il grafo nella Figura 6.2, in cui SXF, CRL, DUB, STN, MAD, TRF, BVA, CIA, NYO sono implicitamente enumerati 0,1,2 8, in quest'ordine.

x = listaAdiacenza[i].inizio; WHILE (x != null) {

j = x.dato; PRINT

(i,j);

PRINT x.peso (se previsto);

x = x.succ;

Tuttavia, la verifica della presenza di un arco tra una generica coppia di nodi i e j richiede la scansione della lista di adiacenza di i oppure di j, mentre tale verifica richiede tempo costante nelle matrici di adiacenza. Non esiste una rappresentazione preferibile all'altra, in quanto ciascuna delle due rappresentazioni presenta quindi vantaggi e svantaggi che vanno ponderati al momento della loro applicazione, valutandone la convenienza in termini di complessità in tempo e spazio che ne derivano. Per quanto riguarda lo spazio utilizzato, la rappresentazione del grafo mediante matrice di adiacenza richiede spazio 0 ( n 2 ) , indipendentemente dal numero m di archi presenti: ciò risulta ottimo per grafi densi ma poco conveniente nel caso in cui trattiamo grafi sparsi in quanto hanno m = O(m) oppure, in generale, per grafi in cui il numero di archi sia m = o ( n 2 ) . Per tali grafi, la rappresentazione mediante matrice di adiacenza risulta poco efficiente dal punto di vista dello spazio utilizzato. Invece, lo spazio è pari

Figura 6.9

I grafi completi

e K 5 e il grafo bipartito completo K33.

a 0 ( n + m) celle di memoria nella rappresentazione mediante liste di adiacenza: infatti la lista per ciascun nodo è di lunghezza pari al grado del nodo stesso e, come abbiamo visto, la somma dei gradi di tutti i nodi risulta essere O(m); inoltre, usiamo spazio O(n) per l'array dei riferimenti. La rappresentazione con liste di adiacenza può essere vista anche come una rappresentazione compatta della matrice di adiacenza, in cui ogni lista corrisponde a una riga della matrice e include i soli indici delle colonne corrispondenti a valori pari a 1. Per avere un metro di paragone per la complessità in spazio, occorre confrontare lo spazio per memorizzare 0 ( n + m) interi e riferimenti, come richiesto dalle liste di adiacenza, con lo spazio per memorizzare un array bidimensionale di 0 ( n 2 ) bit, come richiesto dalla matrice di adiacenza. Per grafi particolari, possiamo usare rappresentazioni succinte nel caso statico come quelle discusse per gli alberi statici (Capitolo 4). Appartengono a questo tipo di grafi sia gli alberi (che hanno n — 1 archi) che i grafi planari, che possono essere sempre disegnati sul piano senza intersezioni degli archi: Euler dimostrò infatti che un grafo planare di n vertici contiene m = O(n) archi e quindi è sparso. Un esempio di grafo planare è mostrato nella Figura 6.2, dove è riportata a destra una sua disposizione nel piano senza intersezioni degli archi {embedding planare). Mentre il grafo completo K4 è planare, come mostrato dal suo embedding planare nella Figura 6.9, non lo sono K5 e il grafo bipartito completo K33 in quanto è possibile dimostrare che non hanno un embedding planare. Da quanto detto deriva che un grafo planare non può contenere né K5 né K3 3 come sottografo: sorprendentemente, questi due grafi completi consentono di caratterizzare i grafi planari. Preso un grafo G, definiamo la sua contrazione G' come il grafo ottenuto collassando i vertici w di grado 2, per cui le coppie di archi (u, w) e (w,v) a essi incidenti diventano un unico arco (u, v): nella Figura 6.6, il grafo G a destra ha il grafo G' al centro come contrazione. Il teorema di Kuratowski-Pontryagin-Wagner afferma che G non è

planare se e solo se esiste un suo sottografo G' la cui contrazione fornisce K5 oppure 1^3. Tale proprietà può essere impiegata per certificare che un grafo non è planare, esibendo G ' come prova che non è possibile trovare un embedding planare di G. Tornando alla rappresentazione nel calcolatore dei grafi, consideriamo il caso di quella per grafi orientati: notiamo che essa non presenta differenze sostanziali rispetto alla rappresentazione discussa finora per i grafi non orientati. La matrice di adiacenza non è più simmetrica come nel caso di grafi non orientati e, inoltre, vengono solitamente rappresentati gli archi uscenti nelle liste di adiacenza. L'arco orientato (i, j) viene memorizzato solo nella lista l i s t a A d i a c e n z a [ i ] (come elemento x contenente j nel campo x . d a t o ) in quanto è differente dall'arco orientato (j,i) (che, se esiste, va memorizzato nella lista l i s t a A d i a c e n z a [ j ] come elemento contenente i). Osserviamo che nei grafi non orientati l'arco (i, j) è invece memorizzato sia in l i s t a A d i a c e n z a f t ] che in l i s t a A d i a c e n z a [ j ] . Nel seguito, ciascuna lista di adiacenza è ordinata in ordine crescente di numerazione dei vertici in essa contenuti, se non specificato diversamente, e fornisce tutte le operazioni su liste doppie indicate nel Paragrafo 5.2. Infine notiamo che, mentre la rappresentazione di un grafo lo identifica in modo univoco, non è vero il contrario. Infatti, esistono n! modi per enumerare i vertici con valori distinti in V = { 0 , 1 , . . . , n — 1} e, quindi, altrettanti modi per rappresentare lo stesso grafo. Per esempio, i due grafi di seguito sono apparentemente distinti:

La distinzione nasce dall'artificio di enumerare arbitrariamente gli stessi vertici ma è chiaro che la relazione tra i vertici è la medesima se ignoriamo la numerazione (ebbene sì, il cubo a destra è un grafo bipartito). Tali grafi sono detti isomorfi in quanto una semplice rinumerazione dei vertici li rende uguali e, nel nostro esempio, i vertici del grafo a sinistra vanno rinumerati come 0-4,

1-1,

2-6,

3-3,

4-5,

5-0,

6-7,

7-2,

per ottenere il grafo a destra: il problema di decidere in tempo polinomiale se due grafi arbitrari di n vertici sono isomorfi equivale a trovare tale rinumerazione, se esiste, in tempo polinomiale in n ed è uno dei problemi algoritmici fondamentali tuttora irrisolti, con molte implicazioni (per esempio, stabilire se due grafi arbitrari non sono isomorfi ha delle importanti implicazioni nella crittografia).

0 1 2 3 4 5 6 7 8 9 10 Figura 6.10

6.1.3

0 1 1 0 0 1 1 0 0 0 0 0

1 1 1 1 1 1 0 0 1 0 0 0

2 0 1 1 0 1 0 0 0 0 0 0

3 0 1 0 1 0 1 1 1 0 0 0

4 1 1 1 0 1 0 0 0 0 0 0

5 1 0 0 1 0 1 1 1 0 0 0

6 0 0 0 1 0 1 1 1 0 0 0

7 0 1 0 1 0 1 1 1 0 0 0

8 0 0 0 0 0 0 0 0 1 1 1

9 0 0 0 0 0 0 0 0 1 1 1

10 0 0 0 0 0 0 0 0 1 1 1

Matrice di adiacenza modificata per il calcolo della chiusura transitiva.

Cammini minimi, chiusura transitiva e prodotto di matrici

La rappresentazione di un grafo G = (V, E) mediante matrice di adiacenza fornisce un semplice metodo per il calcolo della chiusura transitiva del grafo stesso: un grafo G* = (V, E* ) è la chiusura transitiva di G se, per ogni coppia di vertici i e j in V, vale (i, j ) € E* se e solo se esiste un cammino in G da i a j. Sia A la matrice di adiacenza del grafo G, modificata in modo che gli elementi della diagonale principale hanno tutti valori pari a 1 (come mostrato nella Figura 6.10). Calcolando il prodotto booleano A 2 = A x A dove l'operazione di somma tra elementi è l'OR e la moltiplicazione è l'AND, possiamo notare che un elemento A2[i][j] = A[i][k] • A[k][j] di tale matrice è pari a 1 se e solo se esiste almeno un indice 0 ^ t ^ n - 1 tale che A[i][t] = A[t][j] = 1 (nella Figura 6.11 a sinistra è mostrata la matrice di adiacenza A 2 corrispondente a quella della Figura 6.10). Tenendo conto dell'interpretazione dei valori degli elementi della matrice A, ne deriva che, dati due nodi i e j, vale A2[i][j] = 1 se e solo se esiste un nodo t, dove 0 ^ t ^ n — 1, adiacente sia a i che a j, e quindi se e solo se esiste un cammino di lunghezza al più 2 tra i e j. L'eventualità che il cammino abbia lunghezza inferiore a 2 deriva dal caso in cui t = i oppure t = j (motivando così la nostra scelta di porre a 1 tutti gli elementi della diagonale principale di A). Moltiplicando la matrice A 2 per A otteniamo, in base alle considerazioni precedenti, la matrice A 3 tale che A3[i][j] = 1 se e solo se i nodi i e j sono collegati da un cammino di lunghezza al più 3: nella Figura 6.11 a destra è mostrata la matrice di adiacenza A 3 corrispondente alla matrice di adiacenza della Figura 6.10. Possiamo verificare che, moltiplicando A 3 per A, la matrice risultante è uguale ad A : da ciò deriva che A l =A 3 per ogni i ^ 3, e che quindi A 3 rappresenta la relazione di connessione tra i nodi per cammini di lunghezza qualunque. Indicheremo in generale 3

0 1 2 3 4 5 6 7 8 9 10 Figura 6.11

0 1 1 1 1 1 1 1 1 0 0 0

1 1 1 1 1 1 1 1 1 0 0 0

2 1 1 1 1 1 0 0 1 0 0 0

3 1 1 1 1 1 1 1 1 0 0 0

4 1 1 1 1 1 1 0 1 0 0 0

5 1 1 0 1 1 1 1 1 0 0 0

6 1 1 0 1 0 1 1 1 0 0 0

7 1 1 1 1 1 1 1 1 0 0 0

8 0 0 0 0 0 0 0 0 1 1 1

9 0 0 0 0 0 0 0 0 1 1 1

10 0 0 0 0 0 0 0 0 1 1 1

0 1 2 3 4 5 6 7 8 9 10

0 1 1 1 1 1 1 1 1 0 0 0

1 1 1 1 1 1 1 1 1 0 0 0

2 1 1 1 1 1 1 1 1 0 0 0

3 1 1 1 1 1 1 1 1 0 0 0

4 1 1 1 1 1 1 1 1 0 0 0

5 1 1 1 1 1 1 1 1 0 0 0

6 1 1 1 1 1 1 1 1 0 0 0

7 1 1 1 1 1 1 1 1 0 0 0

8 0 0 0 0 0 0 0 0 1 1 1

9 0 0 0 0 0 0 0 0 1 1 1

10 0 0 0 0 0 0 0 0 1 1 1

Matrici di adiacenza A 2 (a sinistra) e A 3 = A* (a destra).

tale matrice come A*, osservando che essa rappresenta il grafo G* di chiusura transitiva del grafo G. Per la corrispondenza tra nodi adiacenti in G* e nodi connessi in G, la matrice A* consente di verificare in tempo costante la presenza di un cammino in G tra due nodi (non consente però di ottenere il cammino, se esiste), oltre che di ottenere in tempo O(n), dato un nodo, l'insieme dei nodi nella stessa componente connessa in G. Poniamoci ora il problema del calcolo efficiente di A* a partire da A, esemplificato dal codice seguente. A' = A; DO { B = A*; A* = B x B ; > WHILE (A* ! = B ) ; RETURN A * ;

Il codice, a partire da A, moltiplica la matrice per se stessa, ottenendo in questo modo la sequenza A 2 , A 4 , A 8 , . . . , fino a quando la matrice risultante non viene più modificata da tale moltiplicazione, ottenendo così A*. Valutiamo il numero di passi eseguiti da tale codice: l'istruzione a riga 1 viene eseguita una sola volta e ha costo 0 ( n 2 ) , richiedendo la copia degli n 2 elementi di A, mentre l'istruzione alla riga 3 e il controllo alla riga 5 sono eseguiti un numero di volte pari al numero di iterazioni del ciclo, richiedendo un costo 0 ( n 2 ) a ogni iterazione. Per quanto riguarda l'istruzione alla riga 4, anch'essa viene eseguita a ogni iterazione e ha un costo pari a quello della moltiplicazione di una matrice n x n per se stessa, costo che indichiamo per ora con Cvi(n). Per contare il numero massimo di iterazioni, consideriamo che la matrice A 1 rappresenta come adiacenti elementi a distanza al più i e che il diametro (la massima distanza tra

Figura 6.12

Grafo rappresentante i 25 stati confinanti nell'Unione Europea in cui la numerazione dei vertici da 0 a 24 è sostituita dalla rispettiva sigla internazionale.

due nodi) di un grafo con n vertici è al più n— 1. Dato che a ogni iterazione la potenza i della matrice A 1 calcolata raddoppia, saranno necessarie al più log(n— 1 ) = 0 ( l o g n ) iterazioni per ottenere la matrice A*. Da ciò consegue che il costo computazionale del codice precedente sarà pari a 0((TI 2 +CM (n.)) logn). Come discusso nel Capitolo 2, abbiamo che CM(TX) = n ( n 2 ) e che CM(TI) = 0 ( n 3 ) con il metodo classico di moltiplicazione di matrici: quindi il costo totale di calcolo di A* è 0 ( n 3 logn). Una riduzione del costo CM(TI) può essere ottenuta utilizzando algoritmi più efficienti per la moltiplicazione di matrici, come ad esempio l'algoritmo di Strassen introdotto nel Paragrafo 2.6.1.

6.2

Opus libri: colorazione di grafi e algoritmi golosi

I grafi permetteno di esprimere i problemi che riguardano lo scheduling di risorse e di attività (come ad esempio l'allocazione di registri nei compilatori e l'assegnamento di frequenze nei cellulari) come un problema di colorazione, in cui vogliamo colorare i vertici con il minimo numero possibile di colori in modo tale che i vertici adiacenti siano colorati diversamente. Prima di discutere un'applicazione reale di tale problema, illustriamo un esempio basato sulla colorazione della cartina dei paesi dell'Unione Europea (in realtà i cartografi usano altri criteri come il bilanciamento dei colori piuttosto che il minimo numero di colori usati). In questo caso, il grafo non orientato G = (V, E) nella Figura 6.12 ha V uguale all'insieme degli n = 25 paesi dell'Unione: inoltre (i, j) € E se e solo se i paesi i e j sono confinanti, per 0 ^ i, j ^ n — 1. Dato un qualunque intero k > 0, una k-colorazione è una funzione x : V >—> { 0 , 1 , . . . , k — 1}, definita sui vertici e indicata con la lettera greca x (chi), che assegna

colori diversi a vertici adiacenti, ovvero x(i-) x(j) P e r ° g n i a r c o (i> j) £ E: il minimo numero k per il quale esiste una k-colorazione viene denominato numero cromatico xo del grafo in questione. Per il grafo considerato, una possibile 4-colorazione è quella che assegna colore 0 ai nodi IRL, E, D, I, SK, S, LIT e EST, colore 1 ai nodi UK, F, NL, DK, PL, A, SF, LTV, GR, CYP e MLT, colore 2 ai nodi B, C Z e SL, e colore 3 ai nodi P, L e H. È possibile d'altra parte verificare che 4 colori sono necessari perché B, F, D, L formano una cricca e, essendo l'uno adiacente agli altri, richiedono colori tutti diversi: pertanto, nel caso del grafo nella Figura 6.12 abbiamo che xo = 4. Per la colorazione vale quanto detto per il cammino e per il ciclo hamiltoniano: dato un intero k ^ 3 non è noto nessun algoritmo che in tempo polinomiale determini se un grafo arbitrario ha numero cromatico k. D'altra parte, osserviamo che, dato un valore k < 0 e un'assegnazione di colori ai nodi, è facile verificare in tempo polinomiale se essa è una k-colorazione: pertanto il problema della k-colorazione è in NP. Come vedremo successivamente, tale problema è in effetti NP-completo. Per alcune famiglie importanti di grafi, tuttavia, la colorazione può essere trovata in tempo lineare. Per esempio, abbiamo appena visto che la cricca K r ha xo = r in quanto ogni coppia di vertici è adiacente. Nel caso di grafi planari, come quello nella Figura 6.12, è sempre possibile trovare una 4-colorazione in tempo lineare, per cui xo ^ 4: questo risultato non è affatto ovvio e discende da una famosa congettura del XIX secolo risolta quasi un secolo dopo da due matematici statunitensi, Kenneth Appel e Wolfgang Haken, con l'ausilio di tecniche algoritmiche e del calcolatore. Pur esistendo dei grafi planari che richiedono Xo = 4 colori, come quello mostrato nella Figura 6.12, altri grafi planari potrebbero richiedere Xo < 4 colori: stabilire se un grafo planare ammette una 3-colorazione è un problema NP-completo. Il problema del calcolo del numero cromatico xo n e ' c a s o di grafi planari è quindi , altrettanto difficile quanto quello per grafi arbitrari. Ciò è sorprendente perché si tratta di stabilire "soltanto" se xo è pari a 3 o 4: infatti, per Xo = L il grafo è composto da un insieme di nodi isolati mentre per xo = 2 è facile progettare un algoritmo che risolve il problema in tempo polinomiale su grafi arbitrari. Vediamo in questo paragrafo che il problema diventa facilmente risolvibile per un'altra classe speciale di grafi, chiamati grafi a intervalli, per cui sviluppiamo algoritmi appositi che ne sfruttano le particolari proprietà.

6.2.1

II problema dell'assegnazione delle lunghezze d'onda

In una rete ottica, i segnali luminosi viaggiano simultaneamente su lunghezze d'onda differenti con una tecnologia che si chiama multiplazione a divisione di lunghezza d'onda. La banda di trasmissione di una fibra ottica viene partizionata in canali multipli, ciascuno dei quali opera a una diversa lunghezza d'onda: ad esempio, una fibra ottica standard a modo singolo può ospitare 128 lunghezze d'onda con una banda pari a 10

gigabit al secondo per ciascuna lunghezza d'onda. Quando un segnale cambia lunghezza d'onda è necessario trasformarlo in un segnale elettrico, instradarlo e riconvertirlo in un segnale ottico con l'opportuna lunghezza d'onda: questo genera un ritardo significativo in quanto il segnale elettrico viaggia molto più lentamente del segnale ottico. 'E quindi più efficiente evitare, per quanto possibile, il cambiamento di lunghezza d'onda del segnale trasmesso: sfruttando la tecnologia ottica, in una rete trasparente i segnali viaggiano da un collegamento all'altro senza cambiare lunghezza d'onda. Un sistema lineare ottico è una rete trasparente composta da un certo numero di collegamenti o linee interconnessi tra loro a formare una sequenza lineare lo, l i , . . . , l s - 1 . Una richiesta di trasmissione del segnale ottico viene rappresentata con l'intervallo chiuso [a,b] se necessita della sequenza di collegamenti l a , l Q + i . . . , l b , dove 0 ^ a ^ b ^ s — 1. Tale richiesta prevede che il segnale viaggi sulla stessa lunghezza d'onda in l Q , l a + i • • •, lb- Tuttavia, bisogna prestare attenzione ad assegnare le lunghezze d'onda alle richieste in modo che non vi siano due segnali che viaggino sulla stessa lunghezza d'onda e interessino uno stesso collegamento. Questo problema, spesso combinato con quello dell'instradamento delle richieste, è stato molto studiato e risulta essere molto difficile in reti ottiche generali: per la sua semplicità, il sistema lineare ottico viene impiegato come base per la progettazione di reti ottiche. Sia R l'insieme di n richieste [ao,bo], [ a i . b i ] , . . . , [ a n _ i , b n _ i ] da soddisfare. Sia inoltre fi la lunghezza d'onda assegnata alla richiesta [ai.bi], per cui l'insieme R è soddisfatto se vale f i ^ f j per ogni coppia di richieste distinte [Qi,bi] e [aj,bj] che condividono almeno un collegamento (ovvero, gli intervalli hanno intersezione non vuota). Il problema dell'assegnazione delle lunghezze d'onda consiste nel soddisfare l'insieme R utilizzando il minimo numero di lunghezze d'onda distinte. Ad esempio, supponiamo che s = 2, n = 3 e R = {[0,1], [0,2], [1,2]}. In questo caso sono sufficienti due lunghezze d'onda: la prima è assegnata alle richieste [0,1] e [1,2], mentre la seconda è assegnata a [0,2], D'altra parte, due lunghezze d'onda sono necessarie in quanto esistono due intervalli che si intersecano.

6.2.2

Grafi a intervalli

Vediamo ora come sia possibile modellare il problema dell'assegnazione delle lunghezze d'onda mediante un problema di colorazione di grafi. In particolare, dato l'insieme R di n richieste [do,boi, [ a i , b ] ] , . . . , [ a n _ i , b n _ i ] , definiamo il grafo GR = (VR, ER) ottenuto da R come segue e come illustrato nella Figura 6.13: l'insieme VR = { 0 , 1 , . . . ,n—1} dei vertici rappresenta gli intervalli in R, dove i e VR corrisponde all'intervallo [at, bi]. L'insieme degli archi ER è definito in base all'intersezione degli intervalli, ovvero (i, j) S ER se e solo se gli intervalli [ai, bi] e [cij, bj] hanno intersezione non vuota (incluso il caso in cui si intersecano in uno degli estremi). Ogni grafo così ottenuto, ovvero che possa essere rappresentato come grafo di intersezione di intervalli, viene detto grafo a intervalli.

Figura 6.13

Un insieme di intervalli e il grafo a intervalli corrispondente.

Usando la formulazione mediante grafo a intervalli, osserviamo che il problema dell'assegnazione delle lunghezze d'onda si riduce al problema della colorazione minima del grafo GR, in cui i colori sono in corrispondenza biunivoca con le lunghezze d'onda. In altre parole, dobbiamo calcolare il numero cromatico xo di GR, e tale numero corrisponde al numero minimo p. = xo di lunghezze d'onda che soddisfano le richieste. Prima di descrivere un algoritmo polinomiale per la risoluzione di quest'ultimo problema, osserviamo che i grafi a intervalli rappresentano gli archi in forma implicita: per esempio, la cricca K n è un grafo a intervalli, in quanto generato da n intervalli, l'uno annidato dentro l'altro. In tal modo, ogni coppia di intervalli ha intersezione non vuota, dando luogo a m = (") archi. Notiamo che i grafi a intervalli sono un sottoinsieme proprio dei grafi: per esempio, il grafo a forma di quadrato (ossia 4 vertici e altrettanti archi) non è un grafo a intervalli. I grafi a intervalli consentono di modellare diverse altre situazioni in cui dobbiamo allocare risorse ad attività da svolgere in un certo intervallo di tempo. Ad esempio, supponiamo di avere un insieme di lezioni da dover pianificare, e che a ognuna sia associato un intervallo temporale all'interno del quale essa debba essere svolta. Se due lezioni si sovrappongono, a esse non può essere assegnata lo stessa aula. Il problema di calcolare il minor numero possibile di aule sufficienti a svolgere tutte le lezioni è ancora una volta equivalente a quello di dover calcolare il numero cromatico del grafo a intervalli corrispondente all'insieme delle lezioni.

I grafi a intervalli hanno anche altre applicazioni, nel campo dell'archeologia (per determinare un ordinamento dell'età di un insieme di artefatti) oppure nel campo della biologia (per la costruzione di mappe del DNA o per la ricerca di geni), per citare alcuni esempi in altre discipline.

6.2.3

Colorazione di grafi a intervalli

L'algoritmo di colorazione del grafo a intervalli sfrutta alcune proprietà geometriche degli intervalli, che supponiamo di avere ordinato in ordine non decrescente in base al loro estremo sinistro, disponendo la sequenza ordinata parallelamente all'asse delle ascisse nel piano cartesiano. Utilizziamo una linea immaginaria di scansione (sweeping line), parallela all'asse delle ordinate, che procede da sinistra verso destra. In ogni istante, la linea interseca un certo numero di intervalli: il numero cromatico xo è almeno pari al massimo numero di intervalli intersecati dalla linea durante la sua scansione. Se consideriamo gli eventi rilevanti che occorrono durante la scansione della linea immaginaria, possiamo notare che il numero di intervalli intersecati cambia soltanto quando la linea incontra un estremo di un intervallo: • se l'estremo è quello sinistro, e quindi incontriamo un nuovo intervallo, a quest'ultimo viene assegnato uno qualunque dei colori non utilizzati dagli intervalli intersecati dalla linea; • se l'estremo è quello destro, e quindi riscontriamo la fine di un intervallo, quest'ultimo rilascia il colore assegnatogli affinché qualcun altro possa usarlo. Per poter essere riutilizzati in seguito, i colori temporaneamente rilasciati vengono mantenuti in un s e c c h i e l l o (bucket), realizzato come un array non ordinato i cui elementi sono inseriti ed estratti in fondo, richiedendo tempo costante per operazione. L'algoritmo garantisce che i colori appartengano all'insieme { 0 , 1 , . . . ,xo — 1} e che due intervalli che si intersecano ricevano colori diversi. L'algoritmo di colorazione di un grafo a intervalli GR è mostrato nel Codice 6.1, dove i parametri d'ingresso sono gli intervalli [do, boi, [aj, bj], . . . , [ a n _ i , b n _ ] ] . Dopo aver azzerato il numero di colori disponibili nel secchiello (che inizialmente è vuoto) e il contatore per il numero di colori usati, procediamo a ordinare gli intervalli in base al loro estremo sinistro (righe 3—7). In particolare, utilizziamo un array di 2 n elementi in cui poniamo le triple (Qv,0,i) e (bi, l , i ) in corrispondenza dell'intervallo [di, b*], per 0 ^ i < n. — 1: la prima componente della tripla contiene un estremo dell'intervallo, la seconda specifica se è un estremo destro (vale 1) o sinistro (vale 0), e la terza contiene l'indice i dell'intervallo. Non possiamo generare due triple uguali, e il successivo ordinamento lessicografico (riga 7) fa sì

ColoraGraf olntervalli ( [a[0], b[0]], [a[l], b[l]],..., [a[n - 1], b[n - 1]] ) : coloriLiberi = numeroColori = 0; FOR (i = 0; i < N; i = i + 1) { estremo[2 x i] = ; estremo[2 x i + 1] = ;

> OrdinaCrescente( estremo ); FÜR (j = 0; j < 2 x n; j = j + 1) { = estremo[j] ; IF (estremoDestro == 1) { secchiello[coloriLiberi] = colore [i]; coloriLiberi = coloriLiberi + 1; > ELSE IF (coloriLiberi > 0 ) {

colore[i] = secchiello[coloriLiberi-1]; coloriLiberi = coloriLiberi - 1; > ELSE

{

colore[i] = numeroColori; numeroColori = numeroColori + 1 ;

> Codice 6.1

Algoritmo per la colorazione di grafi a intervalli, dove s e c c h i e l l o è una semplice sequenza non ordinata.

che gli intervalli che condividono lo stesso estremo siano ordinati in modo che vengano prima le triple associate a intervalli che iniziano in tale estremo di quelle associate a intervalli che terminano in esso. Il successivo ciclo (righe 8 - 2 0 ) scandisce gli intervalli in ordine, per simulare la linea immaginaria, e assegna i colori agli intervalli memorizzandoli nell'array c o l o r e . Preso l'estremo dell'intervallo corrente, non importa il valore di tale estremo ma piuttosto se è destro o sinistro: la seconda componente della tripla fornisce quest'informazione, mentre la terza componente ci indica che siamo nell'intervallo [ai, b j (riga 9). Utilizziamo ora il fatto che quando incontriamo un estremo destro, rilasciamo il colore riponendolo nel secchiello (righe 10—12). Nel caso in cui incontriamo un estremo sinistro, dobbiamo o prelevare uno dei colori nel secchiello (se non è vuoto, come nelle righe 13-15) oppure utilizzare un nuovo colore mai usato prima (righe 16—18). Questo algoritmo produce una k-colorazione del grafo, dove il numero k di colori è pari a n u m e r o C o l o r i : dimostriamo ora che l'algoritmo utilizza il minor numero possibile di colori, e quindi che n u m e r o C o l o r i = xo al termine dell'algoritmo. A tale scopo, per ogni nodo i, indichiamo con P(t) i nodi adiacenti a i ai quali, nel momento

in cui considera di, l'algoritmo ha già assegnato un colore. Tali nodi corrispondono a intervalli che iniziano prima di, o con, a^ e che terminano dopo, o con, cu: pertanto, tutti questi nodi, incluso i, corrispondono a intervalli che si intersecano in cu, e quindi l'insieme P(i) U {i} forma una cricca. In particolare, se i è un nodo in corrispondenza del quale la variabile n u m e r o C o l o r i deve essere incrementata, questo implica che | P(i) |= n u m e r o C o l o r i , e il grafo contiene una cricca di | n u m e r o C o l o r i | +1. Se consideriamo il valore di n u m e r o C o l o r i al termine dell'algoritmo, abbiamo che il grafo contiene una cricca di tale dimensione: da ciò deriva che xo ^ n u m e r o C o l o r i . Dato che l'algoritmo ha effettuato una k-colorazione dove k = n u m e r o C o l o r i , ne deriva che tale colorazione è ottima. Per quanto riguarda la complessità dell'algoritmo, notiamo che il costo dominante è quello dell'ordinamento (riga 7) in quanto il resto del codice richiede tempo O(n). Infatti, il primo ciclo richiede n iterazioni di tempo costante mentre il secondo ciclo ne richiede 2n, in cui ciascuna operazione sul secchiello richiede tempo costante. Ne risulta, in generale, una complessità totale di O ( n l o g n ) tempo. ALVIE: colorazione di grafi a intervalli

Osserva, sperimenta e verifica IntervalGraphColoring

6.2.4

Massimo insieme indipendente in un grafo a intervalli

Il problema della colorazione dei nodi di un grafo è solo uno dei tanti problemi su grafi che, in generale, sono NP-completi, ma che divengono risolvibili in tempo polinomiale nel momento in cui li restringiamo a grafi a intervalli: un altro esempio di tali problemi è quello della ricerca del massimo insieme indipendente. Definiamo un insieme indipendente (independent set) come un sottoinsieme I r di r vertici, il cui sottografo indotto non possiede archi: IT è, quindi, complementare alla cricca K r che invece possiede tutti gli archi possibili. In generale, dato un grafo G, trovare un suo insieme indipendente di cardinalità massima è un problema NP-completo: notiamo come tale problema possa essere visto come un problema di colorazione, consistente nell'individuare il massimo numero di nodi che possono essere correttamente colorati facendo uso di un solo colore. In questo paragrafo, mostriamo che ciò è risolvibile in tempo polinomiale nel caso di grafi a intervalli.

Il problema del massimo insieme indipendente ha diverse applicazioni in molti contesti reali: l'esempio principe, in tal senso, è quello dell'assegnazione (scheduling) a un singolo elaboratore (sia esso umano, meccanico o elettronico) del massimo numero di compiti da eseguire. Ipotizzando, infatti, che i compiti non possano essere frazionati e che sussista tra i compiti una relazione di compatibilità, possiamo modellare tale problema nel modo seguente. Definiamo un grafo G i cui nodi corrispondono ai compiti da eseguire e i cui archi rappresentano la relazione di compatibilità tra di essi (ovvero, esiste un arco tra il compito t e il compito t ' se e solo se t e t ' possono essere entrambi eseguiti dall'elaboratore): un massimo insieme indipendente di G rappresenta una soluzione ottimale per il problema dell'assegnazione di compiti. Nel caso in cui i compiti siano specificati come intervalli di esecuzione, attraverso un tempo di inizio e un tempo di fine, e che due compiti siano compatibili se e solo se i loro corrispondenti intervalli non si intersecano, il problema dello scheduling si riduce a quello della ricerca del massimo insieme indipendente all'interno di un grafo a intervalli. L'algoritmo polinomiale per la risoluzione di tale problema è abbastanza simile a quello visto in precedenza per il problema della colorazione. Anche in questo caso, scandiamo gli intervalli da sinistra verso destra: ogni qualvolta incontriamo la fine di un intervallo che non ne interseca un altro precedentemente assegnato all'elaboratore, decidiamo di assegnare tale intervallo all'elaboratore stesso. In altre parole, questo approccio cerca di rendere l'elaboratore nuovamente disponibile il prima possibile, preferendo assegnare a esso i compiti che terminano prima. Il Codice 6.2 realizza questa strategia, ipotizzando per semplicità che gli intervalli abbiano gli estremi destri distinti e che quindi possano essere ordinati in modo crescente in base ai loro estremi destri (righe 3—6). Una volta eseguito l'ordinamento, l'algoritmo esamina uno dopo l'altro gli intervalli in base a tale ordine (righe 8-16) e, per ciascuno di essi, verifica (riga 10) se è il primo esaminato ( u l t i m o < 0) e, quindi, il primo a terminare, oppure se il suo tempo di inizio è successivo al tempo di conclusione dell'ultimo intervallo precedentemente assegnato (QÌ > b u i t imo)- Se è così, assegna l'intervallo esaminato e aggiorna il riferimento all'ultimo intervallo assegnato (righe 11 e 12), mentre in caso contrario decide di non assegnare l'intervallo esaminato (riga 14). Osserviamo anzitutto che la soluzione prodotta dal Codice 6.2 è un insieme indipendente. In effetti, in base alla guardia della riga 10 e al fatto che gli intervalli sono esaminati-in ordine crescente rispetto al loro tempo di conclusione, un intervallo che viene incluso nella soluzione non interseca nessuno di quelli precedentemente inclusi. Tale soluzione è anche ottimale, ovvero non può esistere un insieme indipendente di cardinalità maggiore. Supponiamo per assurdo che esista un insieme indipendente M tale che |M| > |S|, dove S è l'insieme indipendente calcolato dall'algoritmo. Supponiamo, inoltre, che i due

InsiemelndipendenteGraf olntervalli ( [a[0], b[0]],..., [a[n — 1], b[n — 1]] ) : (pre: i valori b[i] sono tutti distinti per 0 ij i SJ n — 1) FOR (i = 0; i < n; i = i + 1) { estremoDestro[i] = ;

> OrdinaCrescente( estremoDestro ); ultimo = -1; FOR (j = 0; j < n; j = j + 1) { = estremo[j]; IF ((ultimo < 0) II (a[i] > b[ultimo])) { assegnati] = TRUE;

ultimo = i; > ELSE { assegnati] = FALSE;

> > RETURN assegna; Codice 6.2

Algoritmo per la ricerca del massimo insieme indipendente in un grafo a intervalli.

insiemi siano in ordine crescente rispetto al tempo di conclusione degli intervalli in essi contenuti: pertanto possiamo considerare M come un insieme di indici { m o , . . . , m.h} tale che b m i < b m i + 1 per 0 ^ i < h, e S come un insieme di indici { s o , . . . , s j J tale che b S i < b Si + 1 per 0 ^ i < k (con h > k). Notiamo che M deve includere un intervallo T i cui tempi di inizio e di conclusione sono entrambi maggiori di b m k . Se dimostriamo che b S k < b m k , allora abbiamo che T viene esaminato dal Codice 6.2 successivamente all'intervallo [ a s k , b s j : in tal caso, T deve essere incluso in S in quanto il suo tempo di inizio è maggiore di b m k > b S k , contraddicendo il fatto che S contiene k intervalli. Per verificare che b Sk ^ b m k , mostriamo per induzione che b S i ^ b m i per 0 ^ i ^ k. Chiaramente, bSQ ^ b m o , in quanto il nostro algoritmo seleziona sempre l'intervallo che termina per primo. Per i > 0, abbiamo per ipotesi induttiva che b S i < b m i _ , . Inoltre, poiché M è un insieme indipendente, deve valere bTTli_1 < a m ( ^ b m i (due intervalli in M non si possono intersecare). Quindi l'intervallo [ a m i , b m J viene esaminato dal Codice 6.2 successivamente all'intervallo [a Si , , b S i ,] d'intervallo [ a S l , b S l ] non può avere un tempo di fine superiore a b m i , ovvero b S i ^ b m i . Abbiamo dunque dimostrato che l'insieme indipendente prodotto dal Codice 6.2 ha la cardinalità massima possibile. Per quanto riguarda la complessità dell'algoritmo, il costo dominante è quello dell'ordinamento, per cui la complessità totale è O ( n l o g n ) tempo.

ALVIE:

massimo insieme indipendente in grafi a intervalli

Osserva, sperimenta e verifica IndependentSet

6.2.5

Paradigma dell'algoritmo goloso

I due algoritmi polinomiali per la risoluzione dei problemi della colorazione di nodi e del massimo insieme indipendente nel caso di grafi a intervalli, seguono uno schema molto simile (non a caso i Codici 6.1 e 6.2 non sono molto diversi tra di loro). In effetti, una volta stabilito un ordine con cui esaminare gli intervalli, entrambi gli algoritmi decidono come comportarsi sulla base di scelte che appaiono in quel momento le migliori possibili. 4 Nel caso del problema della colorazione, ogni qualvolta esaminiamo un nuovo intervallo, decidiamo di assegnargli, se possibile, un qualunque colore tra quelli già utilizzati: in questo caso, il criterio adottato è quello di non utilizzare nuovi colori se non è necessario. Nel caso del problema del massimo insieme indipendente, invece, ogni qualvolta esaminiamo un nuovo intervallo decidiamo di includerlo nella soluzione se ciò è compatibile con quanto fatto fino a quel momento: in questo caso, quindi, il criterio adottato è quello di assegnare un compito se è possibile farlo. I due criteri sopra esposti conducono l'algoritmo di risoluzione a comportarsi in modo goloso, nel senso che spingono l'algoritmo a operare delle scelte solamente sulla base della situazione attuale, senza cercare di prevedere le conseguenze di tali scelte nelfuturo: per questo motivo, diciamo che i Codici 6.1 e 6.2 si basano sul paradigma dell'algoritmo goloso (greedy algorithm). Tale paradigma (che difficilmente può essere formalizzato in modo più preciso) risulta talvolta, ma non così spesso, vincente: il suo successo, in verità, dipende quasi sempre da proprietà strutturali del problema che non sempre sono evidenti. Nel caso dei due problemi su grafi a intervalli, abbiamo sfruttato proprietà geometriche del problema intrinseche alla sua restrizione al caso di grafi a intervalli. Osserviamo che, nonostante la sua semplicità, il paradigma dell'algoritmo goloso non risulta essere quasi mai una strategia facile da applicare. Una delle difficoltà principali da affrontare consiste nel decidere in che ordine dobbiamo esaminare i componenti di un'istanza del problema. Nel caso del problema del massimo insieme indipendente in grafi a intervalli, avremmo potuto decidere di esaminare gli intervalli ordinati in 4 N o n è in realtà la prima volta che incontriamo un algoritmo che si comporta in questo modo: la strategia SJF descritta nel Paragrafo 2.2, infatti, ordina i programmi da eseguire sulla C P U in base al loro tempo di esecuzione e, quindi, li assegna a essa in base a tale ordinamento.

al loro tempo di inizio, piuttosto che in base al loro tempo di fine: in tal caso, è facile verificare che l'algoritmo goloso corrispondente non calcola un insieme indipen- r dente di cardinalità massima. Supponiamo, infatti, che gli intervalli siano [1,10], [2, 5] e [6,9]: in tal caso, l'algoritmo goloso restituisce come soluzione l'insieme formato dal solo intervallo [1, 10], mentre l'insieme di cardinalità massima è costituito dagli altri due intervalli. L'algoritmo goloso può essere riformulato in termini di programmazione dinamica in cui, una volta ordinati in modo opportuno gli elementi di un'istanza, decomponiamo un problema in un unico sotto-problema, definito eliminando l'ultimo elemento nell'ordine specificato: la fase di ricombinazione consiste nel decidere in modo goloso se e in che modo aggiungere tale elemento alla soluzione del sotto-problema. In conclusione, il paradigma dell'algoritmo goloso non è, in generale, più semplice da utilizzare di quello della programmazione dinamica e raramente consente di risolvere in modo esatto un problema computazionale (anche se esso è stato applicato con un certo successo nel campo delle euristiche di ottimizzazione combinatoria e degli algoritmi di approssimazione). base

6.3

Grafi casuali e modelli di reti complesse

In molti contesti una struttura modellabile mediante un grafo deriva come conseguenza di una serie di attività svolte in modo indipendente, senza alcun coordinamento comune. I risultanti grafi non sono ottenuti da processi guidati da un qualche tipo di controllo centrale, ma piuttosto si accrescono per mezzo di processi evolutivi, in cui nuovi nodi e nuovi archi sono aggiunti al grafo sulla base di informazioni e caratteristiche locali, ignorando la struttura generale del grafo stesso. Tali strutture, denominate reti complesse, presentano l'ulteriore e non secondaria caratteristica di avere una dimensione molto elevata, sia in termini di archi che di nodi. Il più noto esempio di tale situazione è fornito dal World Wide Web, che può essere modellato mediante un grafo orientato in cui i nodi rappresentano pagine e gli archi rappresentano riferimenti {link) tra le pagine stesse. Tale grafo si è formato in modo "casuale", intendendo con tale termine il fatto che la creazione (o l'eliminazione) di nodi o archi avviene al di fuori di controlli centralizzati: ogni utente decide individualmente e indipendentemente i contenuti delle proprie pagine e i riferimenti ad altre pagine. Altri tipi di situazioni modellate mediante reti complesse compaiono in contesti molto diversi tra loro, di cui mostriamo ora alcuni esempi significativi. Le reti sociali sono usate per rappresentare persone, o gruppi di persone, e un qualche tipo di relazione tra loro, come l'amicizia e la conoscenza, ma anche relazioni di collaborazione nella produzione scientifica (ad esempio Erdos number) o compresenza quali interpreti in uno stesso ¿ film (ad esempio Six Degrees of Kevin Bacon, in breve ÓDKB). A tale proposito, il grafo

non orientato di 6DKB è un esempio frequentemente citato di tali reti, i cui nodi sono gli attori cinematografici e dove due nodi sono collegati mediante un arco se e solo se i due attori corrispondenti hanno recitato in uno stesso film. Dato un attore, il gioco consiste nel trovare un cammino fino all'attore Kevin Bacon; in alternativa, dati due attori, bisogna trovare un cammino che li collega. Alla data del 1997, il grafo di 6DKB conteneva più di 200.000 nodi collegati da circa 13 milioni di archi (nel 2005, il numero di nodi è diventato circa 800.000, ma per motivi di completezza faremo riferimento ai dati del 1997). Un'ulteriore tipologia di reti sociali, infine, è rappresentata da grafi in cui gli archi rappresentano comunicazioni di un qualche tipo, quali ad esempio scambio di messaggi (di posta ordinaria o elettronica) o chiamate telefoniche (ad esempio quello noto come AT&T caligraph). Le reti di informazioni sono utilizzate per rappresentare relazioni di rimando tra documenti di una qualche natura. Il grafo del Web è un esempio di rete di questo tipo, come anche i grafi costruiti per rappresentare l'insieme delle citazioni tra articoli di ricerca scientifica che appaiono nella loro bibliografia. Le reti tecnologiche rappresentano la struttura di reti di tipo tecnologico, quali ad esempio reti di distribuzione (elettrica, telefonica, ma anche Internet) o reti di trasporto (strade, ferrovie, collegamenti aerei e marittimi). Le reti biologiche infine modellano relazioni che sorgono in campo biologico, sia a livello di biologia molecolare e genetica che di etologia (relazioni predatore-preda) e di medicina (reti neurali, reti vascolari). L'obiettivo dello studio di grafi di questo tipo è quello di ottenere una caratterizzazione di parametri ritenuti significativi: ad esempio, cerchiamo le proprietà che caratterizzano la rete come il diametro del grafo corrispondente (la distanza tra i due nodi più lontani), o la distribuzione del grado dei nodi. Inoltre, visto che oggetto dello studio non sono in realtà i singoli grafi, ma le famiglie di grafi che modellano una stessa tipologia di relazione o sistema (ad esempio tutti i grafi che rappresentano la relazione di conoscenza tra persone, per insiemi diversi di persone), tale caratterizzazione è di tipo statistico. In definitiva, cerchiamo di ottenere una caratterizzazione, e quindi un modello matematico, della struttura generale di un qualunque grafo di grandi dimensioni che rappresenti una rete del tipo di quelle citate sopra. Tale caratterizzazione potrà essere utilizzata per comprendere le caratteristiche fondamentali del processo che ha portato alla costruzione del grafo risultante e per costruire algoritmi che generino istanze di grafi statisticamente simili a quelli considerati. Ciò permetterà di simulare e prevedere il risultato futuro del processo alla base della costruzione del grafo esaminato, e quindi il comportamento futuro della rete. Usando tale conoscenza possiamo inoltre costruire algoritmi che operano efficientemente, almeno in senso statistico, su tali grafi, utilizzando a tal fine le caratteristiche dei grafi stessi.

Esaminando le reti complesse finora studiate dai ricercatori, emergono alcune caratteristiche comuni. In primo luogo, il numero di archi è limitato rispetto al loro numero massimo, vale a dire m n ( n — 1 )/2, dove n è il numero di nodi e m è il numero di archi. È stato cioè osservato che le reti complesse esaminate tendono a essere sparse. In secondo luogo, le reti complesse tendono a presentare raggruppamenti di nodi o aggregazioni (cluster): intuitivamente, un insieme di nodi adiacenti a uno stesso nodo tende a formare una cricca. Come vedremo, l'abbondanza di aggregazioni in una rete viene misurata a partire da un parametro associato ai singoli nodi, denominato coefficiente di aggregazione: dato un nodo v, il relativo coefficiente di aggregazione C v è il rapporto tra il numero di archi presenti nel sottografo indotto dai nodi adiacenti a v, e il massimo numero possibile di archi tra tali nodi, corrispondente al caso in cui tali nodi formino una cricca. Formalmente,

= ^ d v ( d v - 1)

(6-1)

dove d v è il grado di v, m v è il numero di archi nel sottografo indotto dai nodi ad esso adiacenti e d v ( d v — 1 ) / 2 è il numero di archi nella cricca Kd v . Il coefficiente C di aggregazione di un grafo, cui faremo riferimento nel seguito, è allora definito come la media, sull'insieme dei nodi del grafo, di C v , vale a dire C = n Y-v C v E stato quindi osservato che, se consideriamo il coefficiente di aggregazione di una rete complessa, tale coefficiente tende ad assumere valori elevati. In terzo luogo, tali reti presentano un diametro relativamente piccolo in considerazione delle due caratteristiche precedenti: il diametro, vale a dire la distanza tra i due nodi più lontani, tende a essere più elevato per grafi sparsi (bisogna percorrere più archi per andare da un nodo a un altro) e per grafi aventi un maggior numero di aggregazioni (gli archi tendono a collegare solo nodi vicini, e archi che realizzano collegamenti "lunghi" sono rari). Invece, nonostante siano sparse e contengano un numero elevato di aggregazioni, molte reti complesse con n nodi hanno un diametro significativamente inferiore al suo valore massimo n . In quarto luogo, le reti complesse presentano una grande varietà nella distribuzione dei gradi dei nodi: vale a dire, esse contengono un numero significativo di nodi per ogni possibile valore del grado, all'interno di un intervallo ampio di tali valori. Descriviamo ora tre modelli classici di grafi casuali utilizzati per descrivere e generare grafi aventi caratteristiche quanto più possibile in accordo, da un punto di vista statistico, con le proprietà fondamentali delle reti complesse illustrate sopra, presentando al contempo dei semplici algoritmi per generare tali grafi in modo efficiente. I tre modelli verrano in particolare analizzati dal punto di vista della distribuzione statistica del coefficiente di aggregazione, del diametro e dei gradi dei nodi.

{pre: 0 ^ p ^ 1)

GeneraErdòsRényi (n, p) : FOR (u = 0; u < n; u = u + 1) { A[u] [u] = 0; FOR (V = u + 1; v < n; v = v + 1) { IF (random() < p) { A [u] [v] = A [v] [u] = 1; > ELSE {

A[u] [v] = A[v] [u] = 0;

> >

> RETURN A; Codice 6.3 Algoritmo per la generazione di un grafo casuale G„, p alla Erdòs-Rènyi.

6.3.1

Grafi casuali alla Erdòs-Rényi

Il modello classico di grafi non orientati costruiti in base a un processo casuale è il cosiddetto modello di Erdòs-Rényi, dal nome dei due matematici ungheresi che lo hanno introdotto alla fine degli anni '50. In tale modello, ipotizziamo di avere un insieme di n nodi e un valore prefissato di probabilità p, con 0 ^ p ^ 1. Nel modello supponiamo inoltre che, data una qualunque coppia di nodi u e v, l'arco (u, v) esista con probabilità p, indipendentemente dalle caratteristiche strutturali del grafo, come ad esempio dalla presenza di altri archi incidenti su u o v. La generazione di un grafo casuale di questo tipo, indicato con la notazione G n , p , può essere effettuata in tempo 0 ( n 2 ) mediante il Codice 6.3 che utilizza una primitiva random() per generare un valore reale r pseudocasuale appartenente all'intervallo 0 ^ r < 1, in modo uniforme ed equiprobabile. ALVIE: generazione di grafi casuali alla Erdòs-Rènyi

Osserva, sperimenta e verifica ErdosRenyiGraph

La distribuzione dei gradi dei nodi in un grafo casuale alla Erdòs-Rényi è descritta dalla probabilità pd che un nodo abbia grado d, probabilità caratterizzata dalla nota distribuzione di Bernoulli pd = (

n

^

1

)p

d

d-p)

n

-

d

-

1

(6.2)

La formula (6.2) deriva dall'osservazione che il grado di un nodo v è pari a d se esiste un sottoinsieme di d nodi, tra gli altri n — 1 nel grafo, a esso adiacenti, tale che nessuno dei rimanenti n — d — 1 nodi è adiacente a v. Ricordiamo che il numero di sottoinsiemi di cardinalità d in un insieme di n — 1 elementi è dato dal coefficiente binomiale ')• Inoltre, per ciascun sottoinsieme, la probabilità che tutti i suoi d nodi siano adiacenti a v è pari a p d , mentre la probabilità che nessuno degli altri n — d — 1 lo sia è data da ( 1 — p ) n _ d _ 1 : da ciò deriviamo la formula (6.2). Una nota proprietà della distribuzione di Bernoulli in (6.2) è la sua approssimabilità, per valori di n sufficientemente grandi, per mezzo della distribuzione di Poisson

pa =

z

-ir

(6.3)

dove z = p ( n — 1) è il grado medio di un nodo. I grafi casuali G n , p presentano ulteriori caratteristiche significative elencate di seguito. Come possiamo vedere nella formula (6.3), la probabilità che un nodo abbia grado d decresce esponenzialmente (ovvero, potremmo dire, precipitevolissimevolmente) al crescere di d. Possiamo mostrare tale proprietà facendo uso della seguente formula di Stirling per l'approssimazione del fattoriale: d! ss d d e~ d v / 27td

(6.4)

Applicando tale approssimazione alla formula 6.3 otteniamo chep^« (f)de-zV2^d, dal che possiamo concludere che se d > ez allora p^ decresce esponenzialmente al crescere di d. Da questo fatto consegue che in un grafo G n , p i gradi dei nodi tendono a essere addensati intorno al valore medio p(n— 1 ), con frazioni di nodi aventi grado maggiore o minore di tale valore che tendono rapidamente a svanire man mano che ci allontaniamo da esso (la nota curva a forma di "campana" centrata attorno al valore medio). A proposito del coefficiente di aggregazione di un grafo di questo tipo, osserviamo che tale valore risulta il più basso possibile, a parità di numero di archi nel grafo stesso: questo deriva dalla considerazione che in un grafo di questo tipo gli archi tendono a essere distribuiti in modo uniforme (addensamenti di archi su un sottoinsieme di nodi risultano poco probabili). Detto altrimenti, se un nodo ha z nodi adiacenti, allora il numero massimo di archi possibili tra i suoi nodi adiacenti è pari a z(z — l ) / 2 e il numero medio di archi presenti tra tali nodi è pari a pz(z — 1 )/2: da ciò consegue che il coefficiente C di aggregazione del grafo è pari a p. Se notiamo però che p è in media la frazione di archi presenti in un qualunque insieme di nodi, possiamo convincerci che non c'è nessun particolare addensamento di archi tra nodi vicini di uno stesso nodo, e quindi nessun effetto significativo di aggregazione.

Il diametro del grafo è con alta probabilità logaritmico nel numero di nodi: tale caratteristica è in realtà dovuta al fatto che, con alta probabilità, il diametro non differisce significativamente dalla distanza media tra due nodi scelti in modo casuale e che quest'ultima è logaritmica nel numero di nodi. Per giustificare informalmente quest'affermazione osserviamo che, indicando con z il grado medio, un nodo avrà all'incirca z nodi adiacenti (a distanza 1), z 2 nodi a distanza 2, z 3 nodi a distanza 3 e, in generale, all'incirca z s nodi a distanza s. Attraverso questo processo di ramificazione è possibile dimostrare che, con alta probabilità, per la distanza media s abbiamo che z s = 0(n), da cui otteniamo che s = 0 ( l o g n / logz). Nonostante le caratteristiche appena enunciate siano di grande utilità in diversi contesti, i grafi casuali di tipo Erdòs-Rényi non sembrano però adatti a rappresentare reti complesse come quelle discusse in precedenza. Tale difformità deriva da due fattori: come osservato sopra, da un lato la distribuzione dei gradi in G n , p risulta troppo accentrata intorno al valore medio rispetto a quanto non avvenga in una rete complessa; dall'altro non si presenta in G n , p alcun fenomeno di aggregazione, al contrario di quanto avviene nelle reti complesse. Un'ulteriore caratteristica significativa dei grafi casuali di tipo Erdos-Rényi riguarda l'andamento della dimensione delle varie componenti connesse al crescere della probabilità p, il quale presenta un effetto cosiddetto di soglia: vale a dire che la dimensione della componente connessa più grande nel grafo cambia al di sotto e al di sopra di un determinato valore di p, denominato appunto soglia. È interessante concludere con l'osservazione che in qualunque grafo, generato casualmente come sopra o meno, esiste sempre un sottografo regolare, come conseguenza della teoria di Ramsey (introdotta dal matematico inglese Frank Ramsey nei primi del Novecento). Ricordiamo che un insieme indipendente è un sottoinsieme I r di r vertici, il cui sottografo indotto non possiede archi e che I r è complementare alla cricca K r che invece possiede tutti gli archi possibili. Il numero di Ramsey R(k, l) è il più piccolo intero tale che ogni grafo con n > R(k, l) nodi contiene K^ oppure li come sottografo. Anche se, in generale, è difficile calcolarlo, Ramsey ha dimostrato che tale numero esiste sempre. In altre parole, il disordine totale è impossibile.

6.3.2

Grafi casuali con effetto di piccolo mondo

A un più attento esame, le reti complesse si collocano in una situazione intermedia tra i grafi casuali di tipo Erdòs-Rényi e i grafi regolari, caratterizzati dal fatto che i nodi hanno tutti lo stesso grado. In particolare, consideriamo i grafi regolari R ni d con n nodi, ciascuno di grado d pari, in cui ogni nodo u è collegato a d nodi in modo circolare (d/2 nodi che lo precedono e altrettanti che lo succedono), come illustrato nella Figura 6.14, dove ciascun nodo u è collegato ai nodi v = u + 1 e v = u + 2 modulo n in quanto d = 4. Il diametro della rete

Figura 6.14

Esempio di rete Rl2,4.

nella figura è pari a 3, mentre il coefficiente di aggregazione risulta pari a 1/2, poiché ogni nodo ha d = 4 vicini collegati da 3 archi (a fronte di 6 archi possibili). In generale, il diametro di R n ,d è 0 ( n / d ) , mentre il coefficiente di aggregazione rimane 1/2. Osserviamo quindi che, da un lato, le reti R n ,d hanno diametro e coefficiente di aggregazione elevati mentre, dall'altro, i grafi di tipo Erdòs-Rényi hanno diametro e coefficiente di aggregazione limitati. In tale scenario, le reti complesse sono ibride poiché combinano un diametro limitato con un elevato coefficiente di aggregazione pur essendo sparse: questa caratteristica viene indicata con il termine piccolo mondo (small world) ed è stata ampiamente divulgata nella letteratura e nella pubblicistica. L'origine del concetto di piccolo mondo deriva in effetti dallo studio di reti sociali, e in particolare della rete delle conoscenze tra persone: un famoso esperimento effettuato dal sociologo Stanley Milgram negli anni '60, cercò di valutare la distanza media tra una qualunque coppia di persone su un grafo di tale tipo, mediante un'operazione di instradamento "cooperativo" di messaggi. Nell'esperimento, una lettera doveva viaggiare da un mittente nel Nebraska a un destinatario nel Massachusetts. La lettera doveva essere inviata dal mittente a un suo conoscente a scelta, in modo tale da avvicinare, a suo avviso, il messaggio al destinatario: il conoscente in questione, e tutti gli intermediari successivi, ricevevano la richiesta di operare nello stesso modo, fino alla consegna della lettera al destinatario effettivo. L'esperimento appurò, sulla base di molti tentativi e contrariamente all'intuizione, che il numero medio di intermediari per ogni messaggio ricevuto dal destinatario era in effetti inferiore a 6: tale risultato dette luogo alla locuzione "6 gradi di separazione" ed è anche la ragione del numero 6 nel nome del grafo 6DKB.

Figura 6.15

Creazione di una rete di piccolo mondo a partire dalla rete regolare nella Figura 6.14.

Un esempio di rete sociale che presenta caratteristiche di piccolo mondo è, infatti, dato proprio dal grafo di 6DKB (dati riferiti all'anno 1997, in cui il numero n di nodi era circa uguale a 225000). Questa rete, con grado medio z pari a 61, ha una distanza media tra due nodi pari a 3,65 e un coefficiente di aggregazione C pari a 0,79. Volendo modellare tale rete come un grafo casuale di Erdòs-Rényi, dobbiamo fissare il valore di p pari a z / ( n — 1 ) ~ 0,00027: in tal caso, la distanza media è circa pari a l o g n / logz ~ 2,99 e il coefficiente di aggregazione è uguale a p ~ 0,00027. La rete 6DKB presenta quindi caratteristiche simili a un grafo casuale per quanto riguarda la distanza media tra nodi, per la quale abbiamo un incremento di circa il 22%, ma diverse rispetto al coefficiente di aggregazione, che risulta superiore per un fattore di circa 3000. La stessa situazione si presenta per il grafo orientato del World Wide Web, avendo anche quest'ultimo caratteristiche di piccolo mondo. Uno studio effettuato sul sottoinsieme del World Wide Web composto dai nodi nel dominio . edu ha ottenuto valori pari a 4,062 per la distanza media tra due nodi (4,048 per il corrispondente grafo casuale) e a 0,156 per il coefficiente di aggregazione (0,0012 per il corrispondente casuale). Per la loro caratteristica intermedia, le reti di piccolo mondo sono solitamente generate partendo da una rete regolare di grado d che viene poi modificata attraverso un uso limitato di casualità, come illustrato nel Codice 6.4, partendo da una rappresentazione mèdiante liste di adiacenza vuote, create attraverso la funzione N u o v a L i s t a , che vengono opportunamente riempite con il metodo A g g i u n g i L i s t a A d i a c e n z a . Il codice produce delle pertubazioni casuali a partire dalle reti R n ,a: infatti, sostituendo le righe 7 - 1 7 con la sola riga 16, otteniamo R n ,d- Tali righe simulano l'eliminazione di un arco (u,v) dalla rete regolare e il contemporaneo inserimento di un arco (u,w) verso un nodo w / v, determinato in modo casuale. In particolare, fissata una probabilità p ' di

GeneraPiccoloMondoCn, p', d): FOR (u = 0; u < N; u = u + 1) listaAdiacenza[u] = NuovaListaC ); FOR (u = 0; u < n; U = u + 1) FOR (j = 1; j <= d/2; j = j + 1) { v = (u+j) '/. n; i = (n-1) x randomO ; IF (i < v) { w = i; > ELSE

{

w = i + 1;

> IF (randomO < p') { AggiungiListaAdiacenzaC u, w ); > ELSE

{

AggiungiListaAdiacenzaC u, v );

>

> AggiungiListaAdiacenzaC x, y ): e.chiave = y; listaAdiacenza[x].InserisciFondoC e ); e.chiave = x; listaAdiacenza[y].InserisciFondoC e ); Codice 6.4

Generazione di un grafo casuale con effetto di piccolo mondo ottenuta perturbando la costruzione di un grafo non orientato regolare di grado d pari.

"ridirezionamento", il codice considera l'uno dopo l'altro tutti gli archi della rete: ogni arco (u,v) considerato viene eliminato con probabilità p ' e sostituito da un arco (u, w), dove w è un nodo determinato in modo casuale e uniforme tra i rimanenti n — 1 nodi (righe 7-12), come illustrato nella Figura 6.15. ALVIE:

generazione di grafi casuali con effetto di piccolo mondo

Osserva, sperimenta e verifica SmallWorldGraph

• _

•

Poiché il numero di archi è m = O ( d n ) , l'algoritmo richiede tempo lineare nella dimensione del grafo. I nuovi archi introdotti vengono a fungere da "scorciatoie" tra regioni diverse del grafo e, come vedremo, sono sufficienti a limitare la distanza media

Figura 6.16

Andamento di L(p')/L(0) (curva continua) e C(p')/C(0) (curva tratteggiata) al crescere della probabilità p'.

tra due qualunque nodi. Al tempo stesso, il coefficiente di aggregazione della rete non viene modificato in modo sostanziale dai nuovi archi introdotti, se la probabilità p ' è sufficientemente piccola. Data la probabilità p ' , indichiamo con L(p') la distanza media tra due nodi nella rete risultante dal Codice 6.4 e con C(p') il suo coefficiente medio di aggregazione. Possiamo confrontare queste due quantità con quelle della rete R n ,d di partenza, che sono indicate con L(0) e C(0) in quanto nessun arco viene cambiato: la Figura 6.16 mostra l'andamento, in funzione della probabilità p ' riportata in ascissa in scala logaritmica, dei rapporti L(p')/L(0) (curva continua) e C(p')/C(0) (curva tratteggiata). Esiste un intervallo all'interno del quale la distanza media è diminuita significativamente mentre il coefficiente di aggregazione è rimasto immutato: in questo intervallo la rete presenta quindi l'effetto desiderato di piccolo mondo. In particolare, potremmo scegliere 0,01 come valore di p ' , ottenendo una trascurabile diminuzione del coefficiente di aggregazione a fronte di una riduzione di oltre l'80% della distanza media. Per quanto riguarda il grado medio dei nodi nella rete così costruita, esso risulta indipendente dal valore p ' in quanto il numero di archi rimane costante al variare di tale probabilità. Osserviamo inoltre che, al variare di p ' , passiamo da una rete in cui tutti i nodi hanno lo stesso grado, per p ' = 0, a una rete simile ai grafi casuali di Erdòs-Rényi, p e r p ' = 1. In ogni caso, la distribuzione del grado dei nodi risulta concentrata intorno al valor medio, cosa che non si verifica in generale per le reti complesse esaminate. Per superare questa limitazione, vediamo un modello alternativo che consente di rappresentare e ottenere grafi casuali con le medesime distribuzioni dei gradi delle reti complesse osservate "in natura", pur non assicurando di generare reti di piccolo mondo.

6.3.3

Grafi casuali invarianti di scala

Una delle caratteristiche rilevanti nelle reti complesse è quella relativa alla distribuzione dei gradi dei nodi. Differentemente dai grafi casuali, questa distribuzione segue una legge di potenza (power law) del tipo Pd ~ d Y in funzione del grado d, dove y > 0 è una costante che dipende dalla rete considerata e che risulta, per i casi osservati, compresa tra 2,1 e 4: per esempio, y ~ 2 , 3 per il grafo di ÓDKB, mentre y ~ 3 per il grafo che modella le citazioni tra articoli di ricerca. La Figura 6.17 riporta un diagramma a scala logaritmica su entrambi gli assi, che mostra l'andamento di una distribuzione con legge di potenza e di una con legge esponenziale, come quella di un grafo casuale. La distribuzione esponenziale presenta un intervallo ristretto in cui assume valori elevati seguito da un punto di caduta ( c u t - o f f ) sulle ascisse, oltre il quale il numero di nodi è praticamente nullo: in sostanza, la rete non presenta nodi con grado significativamente superiore al punto di caduta, che definisce, quindi, un limite superiore sul possibile grado di un nodo. E possibile verificare che una distribuzione a legge di potenza risulta invariante di scala, vale a dire che essa appare uguale a se stessa, indipendentemente dalla scala a cui viene esaminata. Diciamo che una funzione f(x) è invariante rispetto alla scala se vale la proprietà f(ax) = g(a)f(x) per ogni a, dove g( ) è una funzione dipendente da f( ). L'idea di fondo è che un incremento di un fattore a nella scala (e quindi nell'unità di misura di x) non determina variazioni di f(x), eccetto che per un fattore moltiplicativo di scala. Anche se, in linea di principio, tale proprietà risulta soddisfatta soltanto da funzioni a legge di potenza, del tipo f(x) = c x a , per le quali vale f(ax) = c ( a x ) a = ( c a a ) x a , è uso comune considerare invarianti di scala anche funzioni che all'infinito tendono a coincidere con funzioni del tipo suddetto. In generale, un grafo è detto invariante di scala se la distribuzione dei gradi dei suoi nodi è una funzione invariante di scala e quindi, in particolare, se segue una legge di potenza. Le reti complesse osservate presentano la caratteristica di essere invarianti di scala, almeno in linea di principio: infatti, esse presentano una distribuzione dei gradi dei nodi che segue una legge a potenza fino a un certo punto, oltre il quale il numero dei nodi decresce rapidamente, anche in considerazione del fatto che la rete ha comunque una dimensione finita. In una rete complessa, quindi, la probabilità che un nodo abbia grado d decresce polinomialmente al crescere di d: pertanto, in una tale rete il grado dei nodi è molto più differenziato che non in un grafo casuale alla Erdòs-Rényi, dove decresce esponenzialmente all'allontanarsi dal valore medio. In una rete complessa compaiono nodi aventi grado più elevato del grado medio, fenomeno assente nei modelli finora discussi. Se consideriamo la struttura del grafo del World Wide Web, ad esempio, possiamo osservare che al suo interno compare una quantità significativa di portali, corrispondenti a nodi aventi grado molto elevato. In effetti, è possibile verificare empiricamente che la

Figura 6.17

Distribuzione con legge a potenza (linea tratteggiata) e distribuzione esponenziale (curva continua) su scala logaritmica.

distribuzione dei gradi in ingresso nel World Wide Web rispetta una legge a potenza con y ~ 2,1, mentre la distribuzione dei gradi in uscita ne rispetta una con y ^ 2,45. L'invarianza di scala delle reti complesse sembra derivare da due fattori. Da un lato, le reti non sono costruite inserendo archi su un insieme di nodi inizialmente privo di archi; al contrario, esse si espandono anche per mezzo di un inserimento continuo di nuovi nodi. Ad esempio, il World Wide Web cresce nel tempo mediante la creazione di nuove pagine, che vengono collegate a quelle già esistenti, così come la rete di collaborazioni tra attori si estende con l'aggiunta di nuovi debuttanti. Inoltre, i nuovi nodi tendono a essere collegati ai nodi aventi grado più elevato: ad esempio, una nuova pagina del World Wide Web tenderà ad avere collegamenti verso i siti più noti, come molte altre pagine. La probabilità con cui un nuovo nodo si collega ai nodi esistenti non è quindi uniforme: al contrario, i nodi aventi grado più elevato hanno maggiore probabilità di essere riferiti dalle nuove pagine secondo il principio per cui "il ricco diventa sempre più ricco". Tra i vari approcci introdotti per costruire grafi non orientati aventi distribuzione dei gradi che rispettino una legge a potenza, il più semplice procede come mostrato nel Codice 6.5, utilizzando liste di adiacenza vuote, create con N u o v a L i s t a ed estese con

GeneraScalabile(n): arrayArchi = {(0,1), (1,2), (2,0)}; F O R (t = 0; t < 3; t = t + 1 ) listaAdiacenza[t] = NuovaLista( ); AggiungiListaAdiacenza( 0, 1 ); AggiungiListaAdiacenza( 1, 2 ); AggiungiListaAdiacenza( 2, 0 ); F O R (t = 2; t < n-1; t = t + 1) { i = (2 x t - 1) x randomO; (u, w) = arrayArchi [i]; arrayArchi[2t-l] = (t+1, u); arrayArchi[2t]= (t+1, w); listaAdiacenza[t+l] = NuovaLista( ); AggiungiListaAdiacenza( t+1, u ); AggiungiListaAdiacenza( t+1, w );

} Codice 6.5

Algoritmo per la generazione di un grafo casuale scalabile.

• Il procedimento inizia all'istante t = 1, in una configurazione in cui il grafo è composto da una cricca K3 con 2t + 1 = 3 archi (e i cui nodi sono 0 , 1 , 2 come mostrato nella righe 2—7). • A ogni istante t ^ 2, il nodo t + 1 viene creato e due nuovi archi incidenti su di esso vengono aggiunti al grafo. A tal fine, un arco ( u , w ) viene determinato in modo casuale (e con distribuzione uniforme) tra i 2t — 1 archi già presenti nel grafo e memorizzati in a r r a y A r c h i (righe 9-10): i due nuovi archi introdotti sono allora (t + l , u ) e (t + l , w ) , dando luogo a un grafo con 2t + 1 archi che collegano t + 2 nodi (righe 11-15). Nella Figura 6.18 mostriamo un esempio di costruzione di un grafo con distribuzione dei gradi dei nodi secondo la legge a potenza, limitatamente ai primi otto nodi. Per ogni passo, riportiamo i valori di t, u , w al fine di determinare quali sono gli archi che sono stati inseriti nel passo stesso.

ALVIE:

generazione di grafi casuali con invariante di scala

Osserva, sperimenta e verifica ScaleFreeGraph

Figura 6.18

Costruzione di grafo scalabile.

Nella costruzione precedente, il grado di un nodo aumenta, a ogni passo, con probabilità tanto maggiore quanto maggiore è il grado del nodo stesso: ciò deriva dal fatto che la probabilità di scegliere un arco incidente su un nodo aumenta al crescere del suo grado (in quanto gli archi vengono scelti in modo uniforme). Pertanto, nodi "ricchi" tendono a diventare sempre più ricchi. Il grafo risultante rispetta una legge a potenza. Consideriamo l'evento che un qualunque nodo v abbia grado d all'istante t e indichiamo con p(d, t) la sua probabilità. Tale evento si verifica: 1. se v aveva grado d — 1 all'istante t — 1 e uno degli archi incidenti su v è stato scelto tra i 2t — 1 archi del grafo, oppure 2. se v aveva grado d all'istante t — 1 ed è stato scelto uno dei 2t — 1 — d archi non incidenti su v. Dato che la probabilità che il nuovo arco scelto sia incidente a v è pari al rapporto tra il grado di v e il numero complessivo di archi nel grafo, ne consegue che, che p(d, t) può essere espressa mediante la seguente relazione di ricorrenza: p(d, t) = ^ - ^ p ( d - l , t - l ) +

2 t

~^~dp(d,t-l).

(6.5)

È possibile dimostrare, a partire dall'equazione (6.5), che la probabilità che un nodo abbia grado d tende, al crescere del numero di nodi, al valore

P(J)=

d ( d + l ' ) 2 ( d + 2) = e ' d ~ 3 > -

verificando così che il grafo ottenuto modella una rete invariante di scala.

6.4

Opus libri: motori di ricerca e classificazione

La disponibilità di grandi quantità di informazioni resa possibile, in particolare, da Internet e il World Wide Web, se da un lato fa sì che abbiamo accesso a una grande quantità di documenti di interesse, dall'altro introduce la necessità di avere informazioni sulla maggiore o minore significatività, ai propri fini, dei documenti accessibili. Una tipica operazione effettuata nell'accesso al Web è quella di richiedere tutti i documenti che soddisfano una certa interrogazione (query), generalmente definita usando i termini presenti nei documenti (per esempio, trovare tutti i documenti contenenti i termini "web" e "searching"). Quest'operazione viene resa possibile dall'utilizzo di motori di ricerca, ovvero di sistemi disponibili in linea che effettuano una raccolta e una catalogazione dei documenti accessibili sul Web e che consentono di interrogare velocemente il catalogo così costruito utilizzando, ad esempio, le liste invertite descritte nel Paragrafo 5.6 (una nota regola empirica stabilisce che la risposta debba essere fornita entro 200 millisecondi affinché un essere umano la percepisca come rapida). Data però la dimensione del Web, la semplice restituzione di un elenco, che può essere molto lungo, di tutti i documenti che soddisfano l'interrogazione non fornisce una soluzione pratica al problema di estrarre le informazioni più rilevanti (per esempio, la ricerca della parola "algoritmo" restituisce oltre due milioni di documenti mentre quella di "web searching" ne restituisce oltre 150 milioni). Vorremmo estrarre dall'elenco di tali documenti un sottoinsieme S con le seguenti caratteristiche: • S contiene relativamente pochi documenti (un centinaio al massimo); • i documenti in S sono rilevanti per l'utente che ha formulato l'interrogazione; • molti dei documenti in S provengono da fonti autorevoli. E quindi necessario che i documenti che soddisfano una certa interrogazione vengano ordinati in modo tale che i più significativi siano presentati prima degli altri: a tal fine, un motore di ricerca effettua, oltre alla ricerca dei documenti, la loro classificazione in base a un valore di significatività o rango (rank) assegnato a ciascun documento, per restituire i documenti stessi ordinati per rango decrescente.

Data una collezione di documenti D, intendiamo definire una funzione r a n g o : D — i > R tale che, per ogni coppia di documenti di e d2 in D, consideriamo di più rilevante di d.2 se r a n g o ( d i ) > rango(d2). Nel caso di collezioni di documenti convenzionali la funzione r a n g o veniva tradizionalmente calcolata sulla base del loro solo contenuto. Con l'avvento delle tecnologie ipertestuali, in cui i documenti possono essere arricchiti con riferimenti ad altri documenti (come nel caso del Web in cui i documenti sono pagine collegate tra di loro), l'insieme dei collegamenti tra i documenti stessi viene utilizzato per estrarre ulteriori informazioni sulla loro significatività: in altre parole, la funzione di rango usa, oltre al contenuto dei documenti, anche la struttura a grafo orientato dell'intera collezione (in cui i vertici sono i documenti e gli archi orientati sono i collegamenti tra di loro). L'intuizione, in questo caso, è che quanto più un documento è riferito da altri documenti, tanto più esso è significativo all'interno della collezione D: infatti, tali riferimenti sono ritenuti essere l'espressione di una forma latente di giudizio umano. In un certo senso, la significatività di un documento viene determinata in modo democratico, attraverso un meccanismo di votazione in cui l'introduzione di un riferimento dal documento di al documento d2 assume la valenza di un voto espresso da di a favore di d2- Se consideriamo quindi il grafo del Web definito sopra, l'intuizione è che una pagina è tanto più significativa quanto maggiore è il grado di ingresso del nodo corrispondente, cioè il numero di archi entranti in tale nodo. Questo approccio alla misurazione del rango di un documento rende il risultato di tale processo particolarmente robusto rispetto a tentativi di modificarne in modo artificioso il risultato, quando una grande quantità di "elettori" ovvero di documenti sono coinvolti. In particolare, nelle situazioni in cui il rango di un documento è calcolato a partire solo dal suo contenuto, quest'ultimo può essere manipolato dal suo produttore (ad esempio, introducendo termini appositi) al fine di aumentare in modo indebito il rango del documento: tale attività è nota, nel caso del Web, come search spam e consiste, ad esempio, nel manipolare elementi di una pagina quali il titolo, le parole chiave e i testi associati ai riferimenti (snippet). Al contrario, una funzione di rango basata anche sui riferimenti tra i documenti risulta di difficile manipolazione da parte di un singolo produttore, e rende quindi il rango stesso più resistente a questo tipo di search spam. Nel processo di votazione appena descritto (basato esclusivamente sul grado di ingresso dei nodi), dobbiamo però tenere presente anche un altro aspetto, cioè che un riferimento proveniente da un documento che ne ha molti in uscita deve avere una rilevanza minore rispetto a quello di un documento che ne ha pochi, perché presupponiamo che nel secondo sia stata effettuata una scelta più accurata dei documenti da riferire. Inoltre, dobbiamo tenere conto anche della significatività dei documenti, in quanto un riferimento proveniente da un documento "autorevole" è più influente rispetto a quello proveniente da uno meno rilevante.

Attualmente, i più importanti motori di ricerca sul Web utilizzano una propria funzione di rango basata sull'analisi dei collegamenti (link analysis) e, in linea di principio, operano secondo il seguente schema comune: 1. impiegano specifici programmi, detti crawler o spider, che visitano e raccolgono le pagine del web seguendo i link che le collegano; 2. analizzano il testo in ogni pagina raccolta e costruiscono un indice di ricerca dei termini che compaiono nelle pagine stesse; 3. tengono traccia dei link tra le pagine, costruendo quindi la matrice di adiacenza del grafo del Web (o meglio, della sua porzione visitata); 4. calcolano, a partire dalla matrice di adiacenza, il rango delle pagine raccolte (o di un loro sottoinsieme) secondo modalità che possono variare da motore a motore. Nel resto di questo paragrafo, discutiamo due approcci che hanno ispirato gli attuali metodi di realizzazione della funzione di rango: osserviamo sin d'ora che tali approcci non sono tra di loro alternativi, ma sono piuttosto complementari. Il primo approccio, detto PageRank e utilizzato da Google insieme ad altri metodi, calcola (e ricalcola periodicamente) il rango di tutte le pagine raccolte: le pagine restituite in seguito a un'interrogazione vengono poi mostrate all'utente in ordine decrescente di rango. Il secondo approccio, detto HITS (Hypertext Induced Topic Selection o selezione degli argomenti indotta dagli ipertesti) e utilizzato inizialmente da Clever dell'IBM, ha in parte ispirato successivi motori di ricerca come Ask, il quale usa ExpertRank: l'approccio HITS identifica prima un opportuno insieme D di pagine che, in qualche modo, sono collegate all'interrogazione e di queste solamente ne calcola il rango che viene utilizzato per decidere l'ordine con cui mostrare le pagine in D. Osserviamo che la collezione D (dominio della funzione r a n g o ) è costituita da tutte le pagine raccolte dai crawler nel caso di PageRank, mentre tale collezione è formata dalle sole pagine collegate all'interrogazione nel caso di HITS: in quest'ultimo caso, la stessa pagina può avere valori di rango diversi a seconda dell'interrogazione. Da quanto appena esposto, è chiaro che i due approcci possono essere combinati utilizzando HITS per raffinare ulteriormente i risultati forniti da PageRank: osserviamo inoltre che i due approcci possono essere usati in generale per calcolare il rango dei nodi di un qualunque grafo orientato o di un suo sottografo indotto, utilizzando i loro archi come meccanismo di votazione.

6.4.1

Significatività delle pagine con PageRank

Come osservato in precedenza, una funzione di rango basata sul sistema di votazione e da applicare al grafo del Web rispetta due principi fondamentali: il rango di una pagina è direttamente proporzionale al rango delle pagine che la riferiscono e inversamente proporzionale al grado in uscita di tali pagine. Il sistema di votazione prevede che ogni pagina esprima almeno una preferenza, ovvero esso interpreta l'astensione di una pagina come una distribuzione uniforme di preferenze a tutte le pagine del Web (per quella

pagina tutte le pagine del Web sono ugualmente importanti). In termini della matrice di adiacenza del Web, ciò vuol dire che le righe con tutti 0 (corrispondenti alle pagine senza link in uscita) diventano righe con tutti 1. A queste osservazioni, dobbiamo aggiungere quella che il tipico navigatore (surfer) non sempre si muove all'interno del Web seguendo un link, ma talvolta utilizza la barra dei comandi di un browser per spostarsi direttamente su una pagina non necessariamente collegata a quella attuale: supponiamo che questo avvenga con probabilità 1 — a con 0 < a < l. 5 Per ogni pagina i, indichiamo nel seguito con E(i) l'insieme delle pagine che riferiscono i e con u s c i t a ( i ) il grado in uscita di i. Il PageRank modella le suddette osservazioni definendo matematicamente la seguente funzione r a n g o per ogni pagina j:

r a n g o ( j ) = (1 - a) + a

Y_ ieE(j)

rango(t uscita(i)

(6.6)

Tale formula intuitivamente descrive il fatto che con probabilità oc la pagina j viene raggiunta seguendo un link da una delle pagine che la riferiscono, mentre con probabilità 1 — a essa viene raggiunta digitando direttamente il suo indirizzo nella barra dei comandi (quando PageRank è stato introdotto, a = 0,85). Sia A la matrice di adiacenza del grafo del Web, ovvero A[i][j] = 1 se e solo se esiste un link dalla pagina i alla pagina j per 0 ^ i, j ^ n — 1, dove n indica il numero di pagine (notiamo che, da quanto osservato in precedenza, per ogni i deve esistere almeno un valore di j tale A[i][j] = 1): quindi, i € E(j) se e solo se A[i][j] = 1. Il calcolo della funzione r a n g o secondo l'equazione (6.6) è esplicitato nel Codice 6.6, che per prima cosa calcola il grado in uscita di ogni nodo e inizializza un array mono-dimensionale di n elementi, detto vettore di rango, per il quale al termine dell'esecuzione vale X[j] = r a n g o ( j ) per 0 ^ j ^ n — 1 (righe 3—8). Il ciclo successivo (righe 9-18) calcola il rango delle pagine usando l'equazione (6.6): poiché tale equazione è ricorsiva, non è sufficiente una sua sola applicazione, ma il calcolo deve essere effettuato in maniera iterativa, in modo che 1 valori calcolati a un passo divengano i valori in ingresso del passo successivo (righe 10 e l i ) , fino a raggiungere il risultato finale (riga 18). In particolare, le righe 12-17 eseguono un passo di tale calcolo iterativo: notiamo che, poiché A[i][)] = 1 se i € E(j) e A[i][j] = 0 altrimenti, il ciclo f o r più interno (righe 14—15) corrisponde al calcolo del valore X!igE(j) usTit°a(V) P r e s e n t e nell'equazione (6.6). Quando il ciclo d o - w h i l e termina (ovvero, il nuovo valore coincide con quello calcolato al passo precedente), il valore di X che viene restituito alla riga 19 soddisfa l'equazione (6.6): pertanto, il Codice 6.6, se termina, calcola il valore di PageRank. 5 In realtà, non stiamo considerando in questo contesto la possibilità che il navigatore utilizzi i pulsanti di navigazione generalmente disponibili nei browser.

PageRank( A ): (pre: A è una matrice binaria n x n, tale che FOR (j = 0; j < n; j = j+1) { uscita[j] = 0; FOR (i = 0; i < n; i = i+1) uscita[j] = uscita[j] + A[j][i]; X[j] = 1;

^Jo' A[i] [j] > 0 per 0 ^ i < n)

> DO { FOR (j = 0; j < N; j = j+1)

Y[j] = X[j] ; FOR (j = 0; j < n; j = j+1) {

X[j] = FOR (i X[j] X[j] =

0; = 0; i < n; i = i+1) = X[j] + A[i] [j] x Y[i] / uscitati] ; ( 1 - a ) + a x X[j] ;

} > WHILE (X != Y); RETURN X; Codice 6.6 Algoritmo per il calcolo di PageRank.

ALVIE:

calcolo di PageRank

Osserva, sperimenta e verifica PageRank

Per quanto riguarda la complessità del codice, ogni iterazione del ciclo d o - w h i l e richiede 0 ( n 2 ) tempo: quindi, la complessità temporale è 0 ( b n 2 ) dove b indica il numero di iterazioni che sono eseguite. In linea di principio, b potrebbe essere un valore infinito, in quanto i valori X e Y calcolati a ogni iterazione potrebbero oscillare senza mai convergere allo stesso valore: inoltre, la convergenza potrebbe dipendere dai valori con cui inizializziamo X (riga 7). Vedremo nel Paragrafo 6.4.3 che ciò non può accadere, facendo uso di strumenti di algebra lineare. Una naturale interpretazione del Codice 6.6 consiste nell'immaginare ogni pagina fornita inizialmente di un "credito" di significatività di default (pari a 1 nel codice): successivamente, ogni pagina decide di distribuire in parti uguali il suo credito alle pagine da essa riferite, ricevendo in cambio un contributo da ciascuna pagina che la riferisce.

Figura 6.19

Effetti dell'apertura verso l'esterno sul valore di PageRank.

Anche se da un Iato aprire all'esterno una pagina, includendo in essa dei link in uscita, causa una perdita di rango, dall'altro una tale apertura può incrementare il numero di riferimenti alla pagina stessa e, quindi, aumentare il flusso di rango in entrata che, in linea di principio, potrebbe compensare e superare quello in uscita. Consideriamo l'esempio mostrato nella parte sinistra della Figura 6.19, in cui il sito Web formato dalle due pagine 0 e 1 è isolato rispetto al resto del mondo (in questo caso rappresentato dalle tre pagine 2, 3 e 4): notiamo che in questa situazione il rango totale del sito formato dalle due pagine (che è pari al numero delle pagine stesse), viene equamente distribuito tra di esse, in quanto le due pagine si riferiscono vicendevolmente. Volendo aprire tale sito all'esterno, possiamo decidere di farlo in diversi modi. Ad esempio, possiamo decidere di collegare la pagina 0 alla pagina 2 e viceversa, come mostrato nella parte centrale della figura (ovviamente, un'apertura verso l'esterno deve essere contraccambiata da un riferimento in entrata): in tal caso, il sito globalmente perde del rango, passando da 2 a poco più di 1. Se, però, decidiamo di collegare la pagina 0 alla pagina 3 e viceversa, come mostrato nella parte destra della figura, la situazione cambia drasticamente: la pagina 0 arriva a un rango superiore a 2 e anche la 1 aumenta leggermente il suo rango, così che il rango totale passa da 2 a 3,3. In altre parole, gestendo l'apertura verso l'esterno in modo opportuno, il rango delle proprie pagine può migliorare significativamente. Un'altra interessante osservazione consiste nel fatto che aprire un sito verso l'esterno può essere accompagnato da una ristrutturazione del sito stesso, in modo da diminuire la quantità di rango che viene perso a causa dell'apertura. Consideriamo la situazione mostrata nella parte sinistra della Figura 6.20, in cui la pagina 3 potrebbe essere una tipica pagina contenente un elenco di riferimenti a pagine esterne al sito formato dalle pagine 0, 1, 2 e 3. Come possiamo vedere, il rango iniziale (pari a 4) del sito si riduce significativamente a causa della pagina 3: il rango totale, dopo

0,42

Figura 6.20

0,8

Effetti della ristrutturazione di un sito web sul valore di PageRank.

l'apertura verso l'esterno, è divenuto pari a circa 2 , 2 1 3 con una perdita del 45%. In questo caso, possiamo progettare una ristrutturazione del sito, aggiungendo delle pagine di recensione delle pagine esterne a cui la pagina 3 fa riferimento e che a loro volta fanno riferimento alla pagina 0 (che funge da home page del sito), come mostrato nella parte destra della figura: cosi facendo il rango che fuoriesce dal sito si riduce significativamente e il rango totale passa da un potenziale di 7 a un valore attuale pari a circa 5,485, con una perdita del 22%. Queste considerazioni mostrano che diverse strategie in grado di manipolare il valore di PageRank sono state progettate allo scopo (generalmente concertato) di migliorare la posizione delle proprie pagine nell'ordine di apparizione e, quindi, di "monetizzare" la creazione di riferimenti. Queste strategie hanno avuto un certo impatto sull'affidabilità del concetto di rango di una pagina Web. Sappiamo che il motore di ricerca Google penalizza esplicitamente le cosiddette fabbriche di link e altre manipolazioni progettate per aumentare artificialmente il rango di una pagina: non conosciamo, però, i meccanismi con cui Google riconosce tali fabbriche e tali manipolazioni. Un altro (non indifferente) svantaggio di PageRank è che esso tende a favorire pagine più vecchie: in effetti, una pagina nuova, anche se molto interessante, non avrà all'inizio molti riferimenti in entrata, a meno che non sia parte di un sito già esistente e con un insieme di pagine fortemente connesse tra di loro. Per tutti questi motivi, Google non usa solo PageRank per calcolare il rango: si vocifera che usi oltre 100 fattori moltiplicativi, tra i quali PageRank è uno dei tanti (e forse nemmeno troppo importante). Google suggerisce, quasi banalmente, che il miglior modo per acquisire un alto rango è quello di creare pagine con contenuti di qualità.

6.4.2

Significatività delle pagine con HITS

La funzione di rango realizzata da HITS è motivata dall'osservazione che le pagine significative per certi termini di ricerca non sempre contengono quei termini stessi: per esempio, né la pagina principale di www. f e r r a r i . i t né quella di www . f i a t . i t contengono esplicitamente il termine "automobile". Inoltre tali pagine non si riferiscono vicendevolmente in modo diretto, mentre lo fanno indirettamente attraverso qualche loro pagina secondaria oppure attraverso siti specializzati per gli appassionati di automobili. Nella terminologia di HITS, le pagine w w w . f e r r a r i . i t e w w w . f i a t . i t sono delle autorità (authority) nel campo automobilistico (mentre non lo sono in quello enologico o di letteratura latina), e un sito specializzato che contiene dei riferimenti a entrambe viene denominato concentratore di collegamenti (hub). Il fenomeno osservato è quindi quello del mutuo rafforzamento in termini di significatività, secondo i seguenti principi: • un concentratore è tanto più significativo quanto lo sono le autorità a cui si riferisce e, quindi, il peso del primo è direttamente proporzionale al peso delle ultime; • un'autorità è tanto più significativa quanto lo sono i concentratori che la riferiscono e, quindi, il peso della prima è direttamente proporzionale al peso degli ultimi. HITS classifica implicitamente le pagine in base ai principi sopra esposti: ogni pagina è simultaneamente un'autorità e un concentratore, chiaramente con peso molto variabile. A tal fine, le seguenti due funzioni di rango sono utilizzate per una data collezione D di documenti: • rangoA(j) misura il peso in D della pagina j intesa come autorità; • rangoC(j) misura il peso in D della pagina j intesa come concentratore. Da quanto osservato sopra, possiamo derivare le equazioni ricorsive che definiscono le suddette funzioni per la pagina j nella collezione D, indicando con E(j) C D l'insieme delle pagine che riferiscono j e con U(j) C D quelle riferite da j, all'interno della collezione stessa: rangoA(j) = ^ rangoC(i) (6.7) iGE(j)

rangoC(j) =

rangoA(k)

(6.8)

k€U(j)

Analogamente al PageRank, possiamo effettuare il calcolo di tali funzioni mediante un procedimento iterativo, assegnando un valore iniziale pari a ^ a ciascuna pagina j e normalizzando di volta in volta il valore di rango, per mantenere l'invariante che £ j € D rangoA(j) = £ j 6 D rangoC(j) = 1.

HITS ( A ) : {pre: A è La matrice di adiacenza di un grafo G con n nodi) FOR (j = 0; j < n; j = j + 1) X[j] = W[j] = 1/n; DO {

sommaX = FOR (j = { Y[j] FOR (j = X[j] = FOR (i X[j] FOR (k W[j] sommaX sommaW

sommaW = 0; 0; j < N; j = j+1) = X[j] ; Z[j] = W[j] ; > 0; j < n; j = j+1) { W[j] = 0; = 0; i < n; i = i+1) = X[j] + A[i] [j] x Z[i] ; = 0; K < N; k = k + 1 ) = W[j] + A[j] [k] x Y[k] ; = sommaX + X[j]; = sommaW + W[j];

} FOR (j = 0; j < n; j = j+1)

{ X[j] = X[j] / sommaX; W[j] = W[j] / sommaW; > > WHILE ((X != Y) Il (W != Z)); RETURN ; Codice 6.7

Algoritmo per il calcolo di HITS.

Per semplificare la notazione, il Codice 6.7 suppone che il sottoinsieme delle pagine del grafo del Web che compongono la collezione D siano state nuovamente numerate da 0 a n — 1 e che A sia la matrice di adiacenza del sottografo del Web indotto dalle pagine in D: quindi, i € E(j) se e solo se A[i][j] = 1 e k G U(j) se e solo se A[j][k] = 1. Il Codice 6.7 inizializza due vettori di rango di n elementi (righe 2 e 3) tali che, al termine dell'esecuzione, vale X[j] = rangoA(j) e W[j] = r a n g o C ( j ) per 0 ^ j ^ n — 1. Il ciclo successivo (righe 4 - 1 9 ) calcola le due funzioni di rango usando le equazioni (6.7) e (6.8): poiché tali equazioni sono ricorsive, i valori calcolati a un passo diventano i valori in ingresso del passo successivo (righe 6 e 7), fino a raggiungere il risultato finale (riga 19). In particolare, le righe 8 - 1 8 eseguono un passo di tale calcolo iterativo: notiamo che il primo ciclo f o r interno (righe 10 e 11) corrisponde al calcolo del valore Z i 6 E ( j ) rangoC(i) (poiché A[i][j] = 1 se i e E(j) e A[i][j] = 0 altrimenti) e che il secondo ciclo f o r (righe 12 e 13) corrisponde al calcolo di ^ L k € U ( j ) rangoA(k) (poiché A[j][k] = 1 se k e E(j) e A[j][k] = 0 altrimenti). Le rimanenti righe del ciclo d o - w h i l e calcolano i valori sommaX e sommaW necessari a normalizzare i valori così calcolati (righe 17 e 18): quando il ciclo d o - w h i l e termina

(ovvero, i nuovi valori coincidono con quelli calcolati al passo precedente), i valori di X e W che vengono restituiti alla riga 20 soddisfano necessariamente l'equazioni (6.7) e (6.8). Pertanto, se termina, il Codice 6.7 calcola correttamente le funzioni di rango definite per HITS. ALVIE:

calcolo di HITS

Osserva, sperimenta e verifica HITS

Analogamente a PageRank, ogni iterazione del ciclo d o - w h i l e richiede 0 ( n 2 ) tempo: quindi, la complessità temporale è 0 ( b n 2 ) dove b indica il numero di iterazioni che sono eseguite (vedremo nel Paragrafo 6.4.3 che b è un valore finito, ovvero il Codice 6.7 termina). A questo punto, è interessante discutere come viene costruita la collezione D di documenti su cui applicare HITS, mostrando anche come esso può integrarsi con altri sistemi di rango. Ipotizziamo di eseguire un'interrogazione utilizzando un motore di ricerca con la propria funzione di rango (come, ad esempio, PageRank), ottenendo così un elenco di risultati: prendiamo i primi t in ordine di rango formando un insieme S di partenza (t = 200 nella proposta originale di HITS). Per ottenere D, estendiamo S con le pagine che appartengono al vicinato di quelle in S: HITS aggiunge a S tutte le pagine in U(j ) per j G S e un opportuno sottoinsieme delle pagine in E(j) per j S S (quest'ultimo potrebbe essere molto vasto). Altre scelte sono possibili: per esempio, possiamo aggiungere anche le pagine con i riferimenti in uscita di secondo livello, ovvero U(k) per k e U(j) e j € S. In tal modo, l'insieme S delle prime t pagine fornite da un motore di ricerca è esteso e raffinato con l'algoritmo di HITS. Il metodo HITS, come quello PageRank, presenta alcuni svantaggi che in qualche modo limitano la sua affidabilità come implementazione del concetto di rango di una pagina Web. Anzitutto, poiché il valore di HITS dipende dall'interrogazione, la costruzione dell'insieme D e il calcolo descritto nel Codice 6.7 devono essere eseguiti ogni volta al momento dell'interrogazione (con ovvie conseguenze dal punto di vista delle prestazióni). Inoltre, HITS è soggetto a meccanismi di search spam al pari di PageRank. Dal punto di vista del produttore di una pagina Web, è infatti facile aggiungere link in uscita e quindi aumentare in tal modo il punteggio di concentratore della pagina stessa: poiché i due punteggi di HITS sono tra di loro dipendenti, questo può portare a un aumento del punteggio di autorità della pagina. Inoltre, cambiamenti locali alla struttura dei

collegamenti possono risultare in punteggi drasticamente diversi, in quanto la collezione D è piccola in confronto all'intero Web. Infine, HITS presenta un cosiddetto problema di "deriva del soggetto" (topic drift), in quanto è possibile che costruendo l'insieme D includiamo una pagina non precisamente focalizzata sull'argomento dell'interrogazione ma con un alto punteggio di autorità: il rischio è che questa pagina e quelle a essa vicine possano dominare la lista ordinata che viene restituita all'utente, spostando così l'attenzione su documenti non proprio inerenti all'interrogazione.

6.4.3

Convergenza del calcolo iterativo di PageRank e HITS

Per dimostrare la convergenza del Codice 6.6 facciamo uso di un famoso risultato di algebra lineare, detto teorema di Perron-Frobenius. Ciò è dovuto al fatto che, come mostriamo in questo paragrafo, possiamo interpretare il codice come un procedimento iterativo per il calcolo della soluzione di un sistema di equazioni lineari: il teorema di Perron-Frobenius ci consente di dimostrare che tale soluzione esiste ed è unica e che viene calcolata da tale procedimento iterativo. Indichiamo con X , k ' il valore del vettore di rango X al termine della k-esima iterazione del ciclo d o - w h i l e del Codice 6.6, per k ^ 1, e con X ( 0 ' il suo valore iniziale (ovvero, formato da tutti 1). In base alle istruzioni eseguite dal Codice 6.6 all'interno del ciclo, possiamo riformulare l'equazione (6.6) come X | k | [j] = (1 - a) + a V i=0

( A[Ì]p]nX
(6.9)

per 0 ^ j < n e k ) 1. Osserviamo che, per ogni k ^ 0, ^"JQ 1 X (k) [j] = n . Ciò è vero per k = 0. Supponendo che lo sia per ogni h. < k e applicando l'equazione (6.9), abbiamo che

"tV'ra j =0

-

+

j=0 i=0

'

<1-«)""Z:^-raEsS i=0

=

v

j=0

n— 1 ( 1 - a ) n +
dove la terza uguaglianza è dovuta al fatto che u s c i t a t i ] = ^.^Jo A[i][)] per ogni 0 ^ i < n, mentre la quarta uguaglianza segue dall'ipotesi induttiva che ^ { ^ Q ' X ( k _ 1 ) [i] = TI.

Mostriamo ora che l'insieme delle equazioni (6.9), una per ogni valore di j, costituisce un sistema di equazioni lineari, che può essere espresso mediante moltiplicazione di matrici. A tal fine, definiamo la matrice M di dimensione n x n , tale che imr-ir-i = M[)][t]

1 _ a

ri

+, otuscitati]

per 0 ^ j , i < n. Possiamo verificare che X,k' = M x X ' k ~ " in quanto X ( k 'tj] = n P e r ° g n ' k ^ 0. Quindi, X ( k ) = M k X ( 0 ) dove ricordiamo k che M è il risultato della moltiplicazione di M per se stessa k volte: pertanto, il Codice 6.6 converge se esiste un k tale che M k = M k _ 1 . Il teorema di Perron-Frobenius ci permette di affermare che ciò è asintoticamente vero in quanto gli elementi di M sono tutti positivi: per ogni e > 0, esiste k e ^ 1 tale che |M k [j][i] — M k - 1 [j][t]| < e per 0 ^ i, j < n . Per questo motivo, la condizione di terminazione del Codice 6.6 deve essere espressa in funzione di un grado di precisione e che deve essere fornito in ingresso insieme alla matrice A. Inoltre, lo stesso teorema garantisce che la soluzione calcolata non dipende dalla scelta di X' 0 '. Il teorema di Perron-Frobenius potrebbe essere applicato anche al Codice 6.7 modificando in modo opportuno la matrice A in ingresso. Tuttavia, altri risultati di algebra lineare consentono di affermare che il Codice 6.7 converge sempre (specificando la condizione di terminazione in base a un grado di precisione), anche se la soluzione calcolata può dipendere dai valori assegnati inizialmente a X e W. RIEPILOGO In questo capitolo abbiamo esaminato le caratteristiche principali dei grafi, fornendo le relative definizioni e mostrando come utilizzarli per modellare una quantità di situazioni e problemi reali. Abbiamo mostrato come rappresentare i grafi e come risolvere, mediante il paradigma dell'algoritmo goloso, il problema della colorazione e del massimo insieme indipendente nel caso di grafi a intervalli. Abbiamo quindi discusso le reti complesse e come generarle probabilisticamente e abbiamo, infine, studiato il problema della classificazione dei documenti nei motori di ricerca utilizzando la struttura a grafo del Web. ESERCIZI 1. Discutete gli algoritmi per inserire o cancellare un nodo o un arco in un grafo in relazione alle due rappresentazioni dei grafi discusse (rappresentazione di grafi dinamici).

2. Il grafo a torneo è un grafo orientato G in cui per ogni coppia di vertici x e y esiste un solo arco che li collega, (x,y) oppure (y,x), ma non entrambi. L'interpretazione è che nella partita del torneo tra x e y uno dei due ha vinto. Mostrate che un grafo a torneo ammette sempre un cammino Hamiltoniano. 3. Descrivete un algoritmo lineare per stabilire se un grafo è bipartito, tentando di usare il colore opposto del vertice corrente quando scoprite un nuovo vertice. 4. Mostrate che le seguenti due varianti del paradigma dell'algoritmo goloso non calcolano un insieme indipendente di cardinalità massima in un grafo a intervalli: (a) una volta ordinati gli intervalli in ordine non decrescente rispetto alla loro lunghezza, l'algoritmo esamina gli intervalli uno dopo l'altro e li include nella soluzione se ciò è possibile; (b) l'algoritmo seleziona l'intervallo con il minor numero di intersezioni, include tale intervallo nella soluzione, elimina tutti gli intervalli che lo intersecano e, se vi sono ancora intervalli, ripete tale procedimento. 5. Mostrate come ridurre la complessità del Codice 6.3 per la costruzione di un grafo alla Erdòs-Rény, da 0 ( n 2 ) tempo a O(np) tempo, quindi con complessità lineare. 6. Mostrate che X | k ) = M x X ( k _ 1 ) , dove X ( h ) per h. ^ 0 e M sono definite nel Paragrafo 6.4.3.

Capitolo 7

Pile e code

SOMMARIO In questo capitolo, definiamo e analizziamo due strutture di dati comunemente utilizzate in contesti informatici (e non solo) per la gestione di sequenze lineari dinamiche, ovvero le pile e le code. Per ciascuna di esse, descriviamo due diversi possibili modi di implementarle e forniamo poi alcuni esempi significativi di applicazione nella gestione della notazione polacca poslfissa, nella visita di grafi, nel loro ordinamento topologico e nel calcolo delle componenti connesse. DIFFICOLTÀ 1 CFU

7.1

Pile

Una pila è una collezione di elementi in cui le operazioni disponibili, come l'estrazione di un elemento, sono ristrette unicamente a quello più recentemente inserito. Questa politica di accesso, detta LIFO (Last In First Out), comporta che l'ordine con cui gli elementi sono estratti dalla pila è opposto rispetto all'ordine dei relativi inserimenti e, ad esempio, riflette quanto avviene per la pila di vassoi, in cui il vassoio che possiamo prendere è sempre quello in cima alla pila che è anche l'ultimo a essere stato riposto. L'insieme delle operazioni caratteristiche di una pila è composto da tre operazioni, due delle quali inseriscono ed estraggono rispettivamente l'elemento in cima alla pila, mentre la terza restituisce tale elemento senza estrarlo. In particolare, la prima operazione prende il nome di P u s h e inserisce un nuovo elemento in cima alla pila; la seconda è detta Pop ed estrae l'elemento in cima alla pila restituendo l'informazione in esso contenuta; la terza è detta Top e restituisce l'informazione contenuta nell'elemento in cima alla pila senza estrarlo. In alcune applicazioni è utile avere anche l'operazione Empty che verifica se la pila è vuota o meno.

Come vedremo, ogni operazione invocata su di una pila può essere eseguita in tempo costante, indipendentemente dal numero di elementi contenuti nella pila stessa: che ciò sia possibile può essere verificato immediatamente considerando il caso della pila di vassoi, in quanto riporre o prendere un vassoio richiede lo stesso tempo, indipendentemente da quanti siano i vassoi sovrapposti. In effetti, se gli elementi nella pila sono mantenuti ordinati secondo l'istante di inserimento, tutte e tre le operazioni agiscono su un'estremità (la cima della pila) della sequenza. Basta quindi avere la possibilità di accedere direttamente a tale estremità per effettuare le operazioni in tempo indipendente dalla dimensione della pila: in questo paragrafo proponiamo due specifiche implementazioni della struttura di dati pila, che consentono effettivamente di fare ciò.

7.1.1

Implementazione di una pila mediante un array

Una pila può essere implementata utilizzando un array. In particolare, gli elementi della pila sono memorizzati in un array di dimensione iniziale pari a una costante predefinita. Successivamente, la dimensione dell'array viene raddoppiata o dimezzata per garantire che sia proporzionale al numero di elementi effettivamente contenuti nella pila: l'analisi del metodo di ridimensionamento di un array (discussa nel Paragrafo 2.1.3) mostra che occorre un tempo costante ammortizzato per operazione. Gli elementi della pila sono memorizzati in sequenza nell'array a partire dalla locazione iniziale, inserendoli man mano nella prima locazione disponibile: ciò comporta che la "cima" della pila corrisponde all'ultimo elemento di tale sequenza. Basterà quindi tenere traccia dell'indice della locazione che contiene l'ultimo elemento della sequenza per implementare le operazioni Push, Pop, Top e Empty in modo che richiedano tempo costante ammortizzato, come mostrato nel Codice 7.1, in cui ipotizziamo che la pila sia rappresentata per mezzo di un array p i l a A r r a y di dimensione variabile (gestito mediante le funzioni V e r i f i c a R a d d o p p i o e V e r i f i c a D i m e z z a m e n t o ) . La cima della pila corrisponde all'elemento dell'array il cui indice è memorizzato nella variabile c i m a P i l a , inizialmente posta uguale a — 1. Facendo uso di tale informazione le operazioni di accesso alla pila sono molto semplici da realizzare. Infatti, l'elemento in cima alla pila sarà sempre p i l a A r r a y [ c i m a P i l a ] . L'operazione P u s h incrementa c i m a P i l a , dopo avere verificato che l'array non sia pieno (nel qual caso la sua dimensione andrà raddoppiata). L'operazione Pop richiede di verificare se la pila non è vuota invocando la funzione Empty e, in tal caso, di decrementare il valore di c i m a P i l a , verificando che l'array non sia poco popolato (nel qual caso la sua dimensione andrà dimezzata). Osserviamo come, nel caso di un'operazione Pop, il contenuto dell'elemento dell'array che si trova nella posizione specificata da c i m a P i l a , non debba essere necessaria-

Push( x ) : VerificaRaddoppio( ); cimaPila = c i m a P i l a + 1; p i l a A r r a y [ c i m a P i l a ] = x; Pop( ) : IF (!Empty( ) ) { x = pilaArrayE cimaPila ] ; cimaPila = c i m a P i l a - 1; VerificaDimezzamento( ) ; RETURN X;

> Top( ) : IF (!Empty( ) ) RETURN p i l a A r r a y t c i m a P i l a ] ; Empty( ) : RETURN ( c i m a P i l a == -1); Codice 7.1

Implementazione di una pila mediante un array: le funzioni Verif icaRaddoppio e VerificaDimezzamento seguono l'approccio del Paragrafo 2.1.3.

mente azzerato, in quanto nel momento in cui faremo di nuovo accesso a tale elemento, il suo contenuto sarà stato modificato dalla corrispondente operazione Push. ALVIE:

implementazione di una pila mediante un array

i n»ì •rr.TTn-rrnM Osserva, sperimenta e verifica

StackArray

7.1.2

Implementazione di una pila mediante una lista

Una pila può essere implementata anche utilizzando una lista i cui elementi sono mantenuti ordinati in base al loro tempo di inserimento decrescente. In tal modo, la "cima" della pila corrisponde all'inizio della lista, e le operazioni agiscono tutte sull'elemento iniziale della lista stessa. Nel Codice 7.2, il riferimento all'elemento in cima alla pila è memorizzato nella variabile c i m a P i l a e ciascun elemento contiene oltre all'informazione un riferimento all'elemento successivo ( c i m a P i l a è n u l i nel caso in cui la pila

Push( x ) : u = NuovoNodo( ) ; u . d a t o = x; u.succ = cimaPila; c i m a P i l a = u; Pop( ) : IF (! Empty( ) ) { x = cimaPila.dato ; cimaPila = cimaPila.succ; RETURN X;

> Top( ) : IF (!Empty( ) ) RETURN c i m a P i l a . d a t o ; Empty( ) : RETURN ( c i m a P i l a == n u l i ) ; Codice 7.2

Implementazione della pila mediante una lista.

sia vuota). Facendo uso di tali riferimenti, le operazioni di accesso alla pila sono quindi altrettanto semplici da realizzare di quelle esaminate nel paragrafo precedente. La modalità di allocazione di un nodo nella lista (riga 2 in Push) dipende dal linguaggio di programmazione adottato. ALVIE:

i m p l e m e n t a z i o n e di u n a pila m e d i a n t e u n a lista

Jhfe^ ^UK/

7.2

Osserva, sperimenta e verifica StackList

Opus libri: Postscript e notazione postfissa

Il Postscript è un linguaggio di programmazione per la grafica che viene eseguito da un interprete che utilizza la pila e la notazione postfissa o polacca inversa definita di seguito. Se un'operazione in Postscript ha k argomenti, questi ultimi si trovano nelle k posizioni in cima alla pila, ovvero l'esecuzione di k operazioni Pop fornisce gli argomenti all'operazione in Postscript, il cui risultato viene posto sulla pila tramite un'operazione Push.

L'ampia diffusione del linguaggio Postscript lo rende uno degli standard tipografici principalmente adottati, insieme alla sua evoluzione PDF (Portable Document Format), per la stampa professionale (inclusa quella del presente libro). Il principio del suo funzionamento basato sulla pila è intuitivo e possiamo illustrarlo usando le espressioni aritmetiche come esempio. È uso comune in matematica scrivere l'operatore tra gli operandi, come in A + B, piuttosto che dopo gli operandi, come in AB+ (nel seguito, supponiamo che gli operatori siano tutti binari). La prima forma si chiama notazione infissa mentre la seconda si chiama postfissa o polacca inversa dalla nazionalità del matematico Lukasiewicz che ne studiò le proprietà. La notazione postfissa ha alcuni vantaggi rispetto a quella infissa. Anzitutto, le espressioni scritte in notazione postfissa non hanno bisogno di parentesi (l'ordine degli operandi viene preservato rispetto all'infissa). In secondo luogo, non è necessario specificare una priorità, talvolta arbitraria, degli operatori (ad esempio, il fatto che A + B x C sia equivalente a A + (B x C) è dovuto al fatto che la moltiplicazione ha, in base a una definizione arbitraria, priorità superiore alla somma). Infine, tali espressioni si prestano a essere valutate semplicemente, da sinistra a destra, mediante l'uso di una pila applicando le seguenti regole in base al simbolo letto, supponendo di avere operazioni binarie: • operando: viene eseguita la P u s h di tale operando; • operatore: vengono eseguite due Pop, l'operatore viene applicato ai due operandi prelevati dalla pila (nel giusto ordine) e viene eseguita la P u s h del risultato. ALVIE:

valutazione di un'espressione postfissa mediante una pila

Osserva, sperimenta e verifica PostfixEvaluation

._

Oltre che per la valutazione di espressioni algebriche in notazione polacca inversa, il tipo di dati pila può essere usato anche per convertire un'espressione algebrica in forma infìssa in un'espressione algebrica equivalente in forma postfissa. Concettualmente, possiamo costruire l'albero che rappresenta l'espressione infissa, visitandolo in ordine posticipato per ottenere l'espressione postfissa, ma possiamo evitare questo doppio passaggio usando direttamente una pila. Supponiamo per semplicità che le parentesi siano comunque esplicitate, per cui un'espressione è data da una coppia di parentesi al cui interno ci sono due espressioni (ricorsivamente definite) separate da un operatore. A questo punto la trasformazione avviene

cima della pila $ 4- oppure — x oppure /

$ 4 2 2

( Figura 7.1

simbolo corrente dell'espressione infissa + oppure — x oppure / ( ) 1 1 1 2 1 1 2 2 2 1 2 1 1 1 3

Tabella per la conversione di un'espressione infissa in una postfissa.

leggendo l'espressione infissa da sinistra a destra e applicando le seguenti regole in base al simbolo letto: • parentesi aperta: viene ignorata; • operando: viene appeso direttamente in fondo all'espressione postfissa in costruzione senza passare per la pila; • operatore: viene eseguita la P u s h di tale operatore; • parentesi chiusa: viene eseguita la Pop per riprendere l'operatore che viene appeso in fondo all'espressione postfissa in costruzione. ALVIE:

conversione di un'espressione infissa con parentesi esplicite in una postfissa

Osserva, sperimenta e verifica F u l l l n f ixPostf ix

In realtà, non abbiamo bisogno di imporre le parentesi nell'espressione infissa quando non sono necessarie. Per verificare tale affermazione, ipotizziamo che l'espressione infissa sia composta dei seguenti simboli: variabili e costanti (ovvero, lettere alfanumeriche), operatori binari (ovvero, + , —, x, / ) e parentesi (ovvero, ( e ) ). Supponiamo inoltre che l'espressione infissa sia sintatticamente corretta (ad esempio, non sia A + xB) e sia terminata dal simbolo speciale $. L'esecuzione delle azioni inizia ponendo una copia del simbolo $ nella pila vuota, e ha termine quando l'espressione infissa diviene vuota. Durante la conversione, se il simbolo corrente nell'espressione infissa è un operando (una variabile o una costante), esso viene appeso direttamente in fondo all'espressione postfissa in costruzione senza passare per la pila. Altrimenti, il simbolo corrente è un operatore, una parentesi oppure il simbolo $, e le regole per elaborare tale simbolo sono rappresentate succintamente nella tabella in Figura 7.1, dove il numero contenuto all'incrocio di una riga e di una colonna rappresenta una delle seguenti azioni, da intra-

prendere quando il simbolo di riga è sulla cima della pila e il simbolo di colonna è quello attualmente letto nell'espressione infissa: 1. viene eseguita la P u s h del simbolo corrente dell'espressione infissa; 2. viene eseguita una Pop e l'operatore così ottenuto viene appeso in fondo all'espressione postfissa in costruzione; 3. il simbolo corrente viene ignorato nell'espressione infissa e viene eseguita una Pop (ignorando il simbolo restituito); 4. la conversione ha avuto termine, il simbolo corrente viene cancellato dall'espressione infissa e viene eseguita una Pop (ignorando il simbolo restituito). Usando la tabella in Figura 7.1, possiamo trasformare anche espressioni che hanno delle parentesi implicitamente definite dall'associatività a sinistra e dalla precedenza degli operatori, come nel caso di 6 + (5 — 4) x ( 1 + 2 + 3). Il costo computazionale dell'algoritmo di conversione e di valutazione è O(n) tempo per un'espressione di n simboli, ipotizzando che il costo di valutazione di un singolo operatore sia costante e quindi non dipenda dalla lunghezza dell'espressione. ALVIE:

conversione di un'espressione infissa in una postfissa

Osserva, sperimenta e verifica InfixPostfix

7.3

Code

Analogamente alla pila, la coda è una collezione di elementi in cui le operazioni disponibili sono definite dalla seguente politica di accesso: mentre nella pila l'accesso è consentito solo all'ultimo elemento inserito, nella coda estraiamo il primo elemento, in "testa" alla coda, essendo presente da più tempo, mentre inseriamo un nuovo elemento in fondo alla coda, perchéè più recente. Ciò corrisponde a quanto avviene in molte situazioni quotidiane come, ad esempio, nel pagare un pedaggio autostradale, nel fare acquisti in un negozio e, in generale, nel ricevere una serie di eventi o richieste da elaborare. Una politica del tipo suddetto viene detta FIFO (First In First Out) in quanto il primo elemento a essere inserito nella coda è anche il primo a essere estratto. Le operazioni principali definite su una coda permettono di inserire un nuovo elemento nella coda e di estrarre un elemento dalla coda stessa in tempo costante: E n q u e u e inserisce un nuovo elemento in fondo alla coda, D e q u e u e estrae l'elemento dalla testa della coda e restituisce l'informazione in esso contenuta e First restituisce l'informazione contenuta nell'elemento in testa alla coda, senza estrarre tale elemento. Infine,

l'operazione Empty verifica se la coda è vuota. Mentre nella pila c'è un unico punto di accesso su cui le operazioni vanno a incidere (quello corrispondente alla "cima" della pila), nel caso della coda ne esistono due, ovvero le estremità della coda stessa, in quanto F i r s t e Dequeue vanno a operare sulla "testa" della coda, mentre Enqueue incide sul "fondo" della coda.

7.3.1

Implementazione di una coda mediante un array

L'implementazione di una coda mediante un array consiste nel memorizzare gli elementi della coda in un array di dimensione variabile. Gli elementi della coda sono memorizzati in sequenza nell'array a partire dalla locazione associata all'inizio della coda, inserendoli man mano nella prima locazione disponibile: ciò comporta che la fine della coda corrisponde all'ultimo elemento di tale sequenza. Basterà quindi tenere traccia dell'indice (indicato con t e s t a C o d a ) della locazione che contiene il primo elemento della sequenza e di quello (indicato con f ondoCoda) della locazione in cui poter inserire il prossimo elemento, per implementare le operazioni F i r s t , Enqueue e Dequeue in tempo costante ammortizzato. Tuttavia, per poter sfruttare al meglio lo spazio a disposizione e non dover spostare gli elementi ogni volta che un oggetto viene estratto dalla coda, la gestione dei due indici t e s t a C o d a e f ondoCoda avviene in modo "circolare" rispetto alle locazioni disponibili nell'array. In altre parole, se uno di questi due indici supera la fine dell'array, allora esso viene azzerato facendo, quindi, in modo tale che indichi la prima locazione dell'array stesso. Nel Codice 7.3, utilizziamo tre interi c a r d C o d a , t e s t a C o d a e f o n d o C o d a che sono stati inizializzati rispettivamente con i valori 0, 0 e — 1 : inizialmente la coda è vuota (quindi, contiene c a r d C o d a = 0 elementi e t e s t a C o d a vale 0) e il prossimo elemento potrà essere inserito nella prima locazione dell'array (quindi, f o n d o C o d a vale — 1 perché viene prima incrementato). Il metodo Empty si limita a verificare se il valore di c a r d C o d a è uguale a 0. L'operazione di incremento di t e s t a C o d a e fondoCoda è circolare, per cui adoperiamo il modulo della divisione intera a tal fine (riga 4 in Enqueue e riga 5 in Dequeue, nelle quali supponiamo che la lunghezza dell'array sia memorizzata nella variabile l u n g h e z z a A r r a y ) . Inoltre, osserviamo che, quando a r r a y C o d a deve essere raddoppiato o dimezzato, le funzioni V e r i f i c a R a d d o p p i o e V e r i f i c a D i m e z z a m e n t o ricollocano ordinatamente gli elementi della coda nelle prime celle dell'array e pongono t e s t a C o d a a 0 e f o n d o C o d a a c a r d C o d a — 1.

7.3.2

Implementazione di una coda mediante una lista

L'implementazione più naturale di una coda mediante una struttura con riferimenti consiste in una sequenza di nodi concatenati e ordinati in modo crescente secondo l'istante di inserimento. In tal modo, il primo nodo della sequenza corrisponde alla "testa" della

Enqueue( x ): VerificaRaddoppio( ); cardCoda = cardCoda + 1 ; fondoCoda = (fondoCoda + 1) "/, lunghezzaArray ; codaArrayt fondoCoda ] = x; Dequeue( ): IF (!Empty( )) { cardCoda = cardCoda - 1; x = codaArrayt testaCoda ]; testaCoda = (testaCoda + 1) '/, lunghezzaArray; VerificaDimezzamento( ); RETURN X;

> First( ) : IF (!Empty( )) RETURN codaArrayt testaCoda ]; Empty( ): RETURN Codice 7.3

(cardCoda == 0);

Implementazione della coda mediante un array: le funzioni Verif icaRaddoppio e Verif icaDimezzamento seguono l'approccio del Paragrafo 2.1.3 e aggiornano anche i valori di t e s t a C o d a e di fondoCoda.

coda ed è il nodo da estrarre nel caso di una D e q u e u e , mentre l'ultimo nodo corrisponde al "fondo" della coda ed è il nodo a cui concatenare un nuovo nodo, inserito mediante Enqueue. Lasciamo al lettore il compito di definire tale implementazione sulla falsariga di quanto fatto per la pila nel Codice 7.2 e per le liste doppie nel Paragrafo 5.2.

7.4

Opus libri: Web crawler e visite di grafi

Abbiamo già visto che uno degli esempi più noti di grafo orientato G = (V, E) è fornito dal World Wide Web in cui l'insieme dei vertici in V è costituito dalle pagine Web e l'insieme degli archi orientati in E sono i collegamenti tra le pagine. Non abbiamo, però, ancora detto come tali collegamenti sono rappresentati all'interno delle pagine e come i crawler di un motore di ricerca (Paragrafo 6.4) possano recuperarli e utilizzarli nel processo di raccolta delle pagine Web. Ogni pagina Web è identificata da un indirizzo URL ( U n i f o r m Resource Locator). Per esempio, / / w w w . w 3 . o r g / A d d r e s s i n g / A d d r e s s i n g . h t m l è l'URL della pagina Web in cui è descritta la specifica tecnica delle URL: la parte racchiusa tra / / e

il primo / successivo (www.w3.org) è un riferimento simbolico a un indirizzo di un calcolatore ospite (host) connesso a Internet. Tale indirizzo è una sequenza di 32 bit se viene utilizzato il protocollo IPv4 (oppure di 128 bit nel caso di IPv6). Infine, la parte rimanente dell'URL, ovvero / A d d r e s s i n g / A d d r e s s i n g . h t m l , indica un percorso interno al file system dell'host, che identifica il file corrispondente alla pagina Web. Un collegamento da una pagina a un'altra è specificato, all'interno della prima, utilizzando la seguente sintassi definita nel linguaggio H T M L (HyperText Markup Language), che permette di associare, tra l'altro, un testo a ogni link con la seguente sintassi testo. Queste informazioni sono utilizzate dai crawler per attraversare il grafo del web in maniera sistematica ed efficiente. Infatti, vista la dimensione del grafo del Web, è improponibile generare tutti gli indirizzi a 32 o 128 bit dei possibili host di siti Web, per accedere alle loro pagine. I crawler effettuano invece la visita del grafo del Web partendo da un insieme S di pagine selezionate: in pratica, S viene formato con gli indirizzi disponibili in alcune collezioni, come Open Directory Project, che contengono un insieme di pagine Web raccolte e classificate da editori "umani". Quando un crawler scopre una nuova pagina, la lista dei link in uscita da essa permette di estendere la visita a ulteriori pagine (in realtà la situazione è più complessa per la presenza di pagine dinamiche e di formati diversi e, inoltre, per altre problematiche come la ripartizione del carico di lavoro tra i vari crawler). Possiamo quindi modellare il comportamento dei crawler come una visita di tutti i nodi e gli archi di un grafo raggiungibili da un nodo di partenza, ipotizzando che i vertici siano identificati con numeri compresi tra 0 e n — 1 (quindi V = { 0 , 1 , . . . , n — 1]) e il numero di archi sia indicato con m = |E|. Osserviamo che gli algoritmi di visita discussi nei seguito Utilizzino le pile e le code discusse finora e funzionano sia per grafi orientati che per grafi non orientati.

7.4.1

Visita in ampiezza di un grafo

Abbiamo già incontrato la visita in ampiezza nel caso degli alberi: tale tipo di visita, che in tal caso prende il nome di BFS {Breadth-First Search), può essere applicato anche a grafi (di cui gli alberi sono un caso particolare), tenendo presente l'esigenza di evitare che la presenza di cicli possa portare a esaminare ripetutamente gli stessi cammini. Nell'esporre la visita in ampiezza su un grafo, faremo inizialmente l'ipotesi che l'insieme dei nodi sia conosciuto: successivamente considereremo il caso più generale in cui tale insieme non sia preventivamente noto. Al fine di esaminare ogni arco un numero limitato di volte (in particolare 2 o 1 in dipendenza del fatto che il grafo sia orientato o meno) nel corso della visita, usiamo un array booleano di appoggio r a g g i u n t o , tale che r a g g i u n t o [u] vale T R U E se e solo se il nodo u è stato scoperto nel corso della visita effettuata fino a ora. Il resto dello

BreadthFirstSearchC s ): FOR (u = 0 ; u < N; u = U + 1) raggiunto[u]

= FALSE;

Q.Enqueue( s ) ; WHILE (!Q.Empty(

))

{

u = Q.Dequeue( ) ; IF (!raggiunto [u]) { raggiunto[u]

= TRUE;

FOR (X = l i s t a A d i a c e n z a [ u ] . i n i z i o ; v = x.dato; Q.Enqueue( v ) ;

x != n u l i ; x = x . s u c c ) {

> > Codice 7.4

Visita in ampiezza di un grafo con n vertici a partire dal vertice s, utilizzando una coda Q inizialmente vuota e un array r a g g i u n t o per marcare i vertici visitati.

schema segue quello visto per gli alberi, in cui la lista di adiacenza del vertice corrente fornisce, come al solito, i riferimenti ai suoi vicini. Il Codice 7.4 riporta lo schema di visita a partire da un vertice prescelto s, dove l i s t a A d i a c e n z a [ u ] . i n i z i o indica il riferimento all'inizio della lista di adiacenza per il vertice u . Dopo aver inizializzato r a g g i u n t o e la coda Q (righe 2-4), inizia il ciclo di visita. Il vertice u in testa alla coda viene estratto (riga 6) e, se non è stato ancora raggiunto, viene marcato come tale e la sua lista di adiacenza viene scandita a partire dal primo elemento (righe 7 - 1 3 ) . Poiché ogni vertice viene inserito nella coda soltanto se non ancora marcato, e quindi una sola volta, ciascuna delle liste di adiacenza esaminate viene anch'essa considerata una sola volta: in conseguenza di ciò, il costo totale della visita è dato dalla somma delle lunghezze delle liste di adiacenza esaminate, ovvero al più dalla somma dei gradi di tutti i vertici del grafo, ottenendo un totale di 0 ( n + m) tempo e O(n) celle di memoria aggiuntive. Un esempio di visita in ampiezza è descritto nella Figura 7.2, dove l'ordine dei vertici in ciascuna lista di adiacenza determina l'ordine di visita dei vertici stessi nel grafo: supponiamo che i vertici in ciascuna lista di adiacenza siano mantenuti in ordine crescente, se non specificato altrimenti. L'ordine con cui i vertici vengono raggiunti dalla visita del grafo illustrato nella parte sinistra della Figura 7.2 è dato da 0 , 1 , 2 , 3 , 5 , 4 , 6 , 7 (l'ordine del loro inserimento nella coda). In particolare, dal vertice 0 raggiungiamo i vertici 1 , 2 , 3 e 5, dal vertice 3 raggiungiamo 4 e 6 e dal vertice 5 raggiungiamo 7 (mentre i rimanenti vertici non permettono di raggiungerne altri). L'esempio illustra alcune proprietà interessanti della visita. Gli archi che conducono a vertici ancora non visitati, permettendone la scoperta, formano un albero detto albero

destra, annotato con gli archi all'indietro tratteggiati e la profondità dei nodi.

BFS, la cui struttura dipende dall'ordine di visita (parte destra della Figura 7.2). Per poter costruire tale albero, modifichiamo lo schema di visita illustrato nel Codice 7.4: invece di usare una coda Q in cui i vertici sono inseriti ed estratti una sola volta, usiamo Q come coda in cui gli archi sono inseriti ed estratti una sola volta. Il Codice 7.5 riporta tale modifica della visita in ampiezza: dopo aver estratto l'arco (u', u) dalla coda (riga 6), scandiamo la lista di adiacenza di u solo se quest'ultimo non è stato scoperto (riga 7). La visita richiede 0 ( n + m) tempo, in quanto ogni arco è inserito ed estratto una sola volta e le liste di adiacenza sono scandite solo quando i corrispondenti vertici sono visitati la prima volta. Utilizzando il Codice 7.5, non è difficile individuare gli archi dell'albero BFS: basta memorizzare l'arco ( u ' , u ) quando il nodo u viene marcato come raggiunto nella riga 8 e, inoltre, u ' diventa il padre di u nell'albero BFS. In generale, gli archi individuati in tal modo formano un sottografo aciclico e, quando gli archi di tale sottografo sono incidenti a tutti i vertici, l'albero BFS ottenuto è un albero di ricoprimento (spanning tree) del grafo, vale a dire un albero i cui nodi coincidono con quelli del grafo. Cambiando l'ordine relativo dei vertici all'interno delle liste di adiacenza, possiamo ottenere alberi diversi. Notiamo infine che tali alberi, avendo grado variabile, possono essere rappresentati come alberi ordinali (Paragrafo 4.4). L'albero BFS è utile per rappresentare i cammini minimi dal vertice di partenza s verso tutti gli altri vertici: tale proprietà è vera in quanto gli archi non sono pesati (altrimenti non è detto che valga, e vedremo successivamente come gestire il caso in cui gli archi sono pesati). Per verificare tale proprietà, basta osservare che l'algoritmo visita prima i vertici a distanza 1 (ovvero i vertici adiacenti a s), poi quelli a distanza 2 e così via, come un semplice ragionamento per induzione può stabilire. In altre parole, la prò-

BreadthFirstSearch( s ) : FOR (u = 0; u < n; u = u + 1) raggiunto[u] = FALSE;

Q.Enqueue( (null, s) ); WHILE (!Q.Empty( )) {

(u', u) = Q.Dequeue( ); IF (!raggiunto[u]) { raggiunto[u] = TRUE;

FOR (x = listaAdiacenza[u].inizio ; x != nuli; x=x.succ) { v = x.dato; Q.Enqueue( (u, v) );

}

> Codice 7.5

Visita in ampiezza di un grafo in cui la coda Q contiene archi anziché vertici.

fondità p di un vertice v nell'albero BFS indica che la sua distanza minima da s nel grafo è proprio p; inoltre, i nodi irraggiungibili da s non vengono inclusi nell'albero BFS, e possiamo considerare che risultino a distanza infinita da s. Per verificare quanto affermato sopra ragioniamo in modo induttivo rispetto alla distanza dei nodi da s: il caso base dell'induzione è banalmente verificato in quanto l'unico nodo a profondità 0 è s che evidentemente ha distanza 0 da sé stesso. Per mostrare il passo induttivo, supponiamo che per ogni nodo u a distanza p ' < p da s la profondità di u. sia pari a p ' e ipotizziamo che esista, per assurdo, un nodo v a distanza 6 da s la cui profondità nell'albero BFS sia p / 6, e quindi tale che il cammino minimo da s a v sia di lunghezza 6. Consideriamo allora sia il vertice v' (a distanza 6—1 da s) che precede v in tale cammino, che il padre u di v a profondità p — 1 nell'albero BFS. Evidentemente, non può essere p < 6 in quanto, in tal caso, il cammino da s a v che attraversa u avrebbe lunghezza minore di 6, il che contraddice l'ipotesi che 6 sia la distanza tra s e v. Al tempo stesso, se 6 < p l'algoritmo di visita avrebbe raggiunto v da v' e quindi v avrebbe profondità 6 (infatti v ' sarebbe stato visitato prima di u). La proprietà appena discussa ha due conseguenze rilevanti. 1. Gli archi del grafo che non sono nell'albero BFS sono chiamati all'indietro (back): possono collegare solo due vertici alla stessa profondità nell'albero BFS oppure a profondità consecutive p e p + 1. 2. Il diametro del grafo può essere calcolato come la massima tra le altezze degli alberi BFS radicati nei diversi vertici del grafo (in generale, ne possono esistere n diversi). Il tempo richiesto per calcolare il diametro è 0 ( n ( n + m)).

BreadthFirstSearchExploreC s ) : Q.Enqueue( s ) ; WHILE ( ! Q . E m p t y (

))

{

u = Q.Dequeue( ) ; IF ( ! D . A p p a r t i e n e ( u ) ) { D.Inserisci(u); FOR (X = l i s t a A d i a c e n z a [ u ] . i n i z i o ; v = x.dato; Q.Enqueue( v ) ;

x != n u l i ; x=x.succ) {

> > Codice 7.6

Esplorazione mediante visita in ampiezza di un grafo, utilizzando una coda Q e un dizionario D per memorizzare i vertici visitati.

Un'altra applicazione interessante è che la visita BFS ci permette di stabilire se un grafo non orientato G è connesso. Infatti, G è connesso se e solo se r a g g i u n t o c i . ] vale T R U E per ogni 0 ^ u. ^ n — 1, ovvero tutti i vertici sono stati raggiunti e quindi abbiamo che l'albero BFS è un albero di ricoprimento. Il costo computazionale è lo stesso della visita BFS, quindi 0 ( n + m) tempo e O(n) celle di memoria. Nel caso in cui l'insieme dei nodi del grafo non sia preventivamente noto, e quindi il grafo debba essere esplorato per determinarne la struttura, non è possibile evidentemente utilizzare un array per distinguere i nodi raggiunti da quelli non ancora trovati. Per ottenere tale funzionalità è necessario fare uso di una struttura di dati che consenta di rappresentare un insieme, nello specifico l'insieme dei vertici raggiunti, dando la possibilità di aggiungere nuovi elementi all'insieme e di verificare l'appartenenza di un elemento all'insieme stesso. Tali funzionalità sono offerte da un dizionario (Capitolo 5), che quindi impieghiamo nel Codice 7.6, che è una semplice riscrittura del Codice 7.4. Nel codice in questione, il dizionario D, inizialmente vuoto, viene in effetti utilizzato in sostituzione dell'array r a g g i u n t o per rappresentare, a ogni istante, l'insieme dei nodi già raggiunti dalla visita. Dal punto di vista del costo computazionale, la sostituzione dell'array con un dizionario fa si che tale costo dipenda dal costo delle operazioni definite sul dizionario, dipendente a sua volta dall'implementazione adottata per tale struttura di dati. In particolare, esaminando il Codice 7.6 risulta che l'operazione I n s e r i s c i è eseguita O(n) volte, mentre l'operazione A p p a r t i e n e è invocata O(m) volte: ad esempio, utilizzando una tabella hash, per la quale le due operazioni richiedono tempo medio 0(1), il costo complessivo della visita è O ( n + m) nel caso medio. Utilizzando invece un

DepthFirstSearchC s ) : FOR (u = 0; u < n ; u = u + 1) raggiunto[u]

= FALSE;

P.PushC s ) ; WHILE ( ! P . E m p t y ( ) )

{

u = P.PopC ) ; IF ( ! r a g g i u n t o [ u ] ) { raggiunto[u]

= TRUE;

FOR (x = l i s t a A d i a c e n z a [ u ] . f i n e ; x != n u l i ; x = x . p r e d ) { v = x.dato; P.PushC v ) ;

> > Codice 7.7

Visita in profondità di un grafo utilizzando una pila P di archi, inizialmente vuota. Ciascuna lista di adiacenza viene scandita all'indietro.

albero di ricerca bilanciato, i costi delle due operazioni sono O(logn) nel caso peggiore, e quindi il costo conseguente dell'algoritmo è 0 ( ( n + m.) logn). ALVIE:

visita in a m p i e z z a di un g r a f o

Osserva, s p e r i m e n t a e verifica BreadthFirstSearch

7.4.2

M ™

•

—

Visita in profondità di un grafo

Se nello schema di visita illustrato nei Codici 7.4 e 7.5 sostituiamo la coda Q con una pila P, otteniamo un altro algoritmo di visita di grafi, noto come algoritmo di visita in profondità, o DFS {Depth-First Search), realizzato dai Codici 7.7 e 7.8. Dato che in una pila un insieme di elementi viene estratto in ordine opposto a quello di inserimento, volendo estrarre dalla pila gli archi incidenti a un nodo u nello stesso ordine con cui li incontriamo scandendo la lista di adiacenza di u , dobbiamo inserire nella pila tali archi in ordine inverso rispetto a quello della lista. Analogamente alla visita in ampiezza, anche nella visita in profondità viene costruito un albero, detto albero DFS, i cui archi vengono individuati in corrispondenza alla scoperta di nuovi vertici.

DepthFirstSearchC s ): FOR (u = 0; u < n; u = u + 1) raggiunto[u] = FALSE;

P.Push( (nuli, s) ); WHILE (!P.Empty( )) {

(u\ u) = P.Pop( ); IF (!raggiunto[u]) { raggiunto[u] = TRUE;

FOR (x = listaAdiacenza[u].fine; x != nuli; x = x.pred) { v = x.dato; P.Push( (u, v) );

> > Codice 7.8

Visita in profondità di un grafo in cui la pila P contiene archi anziché vertici.

La visita in profondità, per la natura stessa della politica LIFO che adotta la pila, si presta in modo naturale a un'implementazione ricorsiva, riportata nel Codice 7.9. Tale implementazione è ampiamente usata in varie applicazioni discusse in seguito, in alternativa a quella iterativa; notate che in questo caso il fatto che l'utilizzo della ricorsione non richieda una gestione esplicita di una pila fa si che non sia più necessario effettuare una scansione al contrario delle liste di adiacenza. Unitamente alla visita ricorsiva, il codice mostra la funzione S c a n s i o n e , che esamina tutti i vertici del grafo alla ricerca di quelli non ancora scoperti, invocando la ricorsione su ciascun nodo s di questo tipo, utilizzandolo come vertice di partenza di una nuova visita. Osserviamo che l'esame di tutti i vertici del grafo in effetti non richiede necessariamente l'adozione di una visita in profondità per ogni nodo non ancora raggiunto: in linea di principio, anzi, potremmo utilizzare tipi di visita diversi. Il costo computazionale delle visite in profondità discusse sopra è analogo a quello della visita in ampiezza, ovvero 0 ( n + m) tempo sia per grafi orientati che per grafi non orientati. Il numero di celle di memoria richieste per la visita iterativa è O(m) mentre per quella ricorsiva è 0 ( n ) . Un esempio di visita di un grafo orientato, a partire dal vertice s = 0, è riportato nella Figura 7.3, dove sono mostrati sia l'albero BFS che l'albero DFS risultanti. Durante la visita in profondità, in particolare, i vertici vengono scoperti nell'ordine 0 , 1 , 2 , 4 , 5 , 3 (quest'ultimo a partire dal vertice 1). Una caratteristica importante della visita D e p t h F i r s t S e a r c h R i c o r s i v a è che la pila implicitamente mantentuta dalla chiamata ricorsiva su un vertice u contiene i nodi, in ordine inverso, lungo il cammino n

Scansione( G ) : FOR (s = 0; s < n ; s = s + 1) raggiunto[s] FOR (S = 0; s

= FALSE;

< n; s = s + 1) { IF ( ¡ r a g g i u n t o [ s ] ) D e p t h F i r s t S e a r c h R i c o r s i v a ( s ) ;

> DepthFirstSearchRicorsiva( u ): raggiunto[u]

= TRUE;

FOR (x = l i s t a A d i a c e n z a [ u ] . i n i z i o ; x != n u l i ; x = x . s u c c ) { v = x.dato; IF ( ¡ r a g g i u n t o [ v ] ) D e p t h F i r s t S e a r c h R i c o r s i v a ( v ) ;

> Codice 7.9

Visita in profondità di un grafo utilizzando la ricorsione.

dell'albero DFS che va dalla radice s al nodo u. In altre parole, esaminando il contenuto della pila implicita per ogni vertice scoperto, otteniamo la visita anticipata dell'albero DFS. Per esempio, quando la chiamata di D e p t h F i r s t S e a r c h R i c o r s i v a esamina il vertice u = 3 nella Figura 7.3, la pila implicita contiene i vertici corrispondenti al cammino 7t = 0 , 1 , 3 nell'albero DFS (il vertice u = 3 è in cima alla pila). Per quanto riguarda invece gli archi non appartenenti all'albero DFS, questi, nel caso di grafi orientati, possono essere classificati ulteriormente. In particolare, un arco (u, v) non appartenente all'albero DFS, può essere catalogato come segue: « all'indietro (back)-, se v è antenato di u nell'albero DFS; • in avanti (forward): se v è discendente di u nell'albero DFS (nipote, pronipote e così via, ma non figlio perché altrimenti l'arco apparterrebbe all'albero); • trasversale (cross): se v e u non sono uno antenato dell'altro. Nei grafi non orientati possono esserci solo archi all'indietro, che sono gli unici a condurre a vertici già visitati durante la visita in profondità. Dall'esempio nella Figura 7.3 emerge anche la differenza tra le due visite. Nella visita in ampiezza, i vertici sono esaminati in ordine crescente di distanza dal nodo di partenza s, per cui la visita risulta adatta in problemi che richiedono la conoscenza della distanza e dei cammini minimi (non pesati): successivamente, vedremo come, in effetti, un limitato adattamento della visita in ampiezza consenta di individuare i cammini minimi anche in grafi con pesi sugli archi. Nella visita in profondità, l'algoritmo raggiunge rapidamente vertici lontani dal vertice di partenza s, e quindi la visita è adatta per problemi collegati alla percorribilità, alla connessione e alla ciclicità dei cammini.

© ©A © © ©

©

avanti

©

V

F

?

(T)

; avanti 'trasversale'

indietro \

© trasversale

XD-'" Figura 7.3

Un grafo orientato, il relativo albero BFS a partire dal vertice s, dove s = 0, e l'albero DFS a partire da s con la classificazione degli archi in avanti, all'indietro e trasversali.

Anche per la visita in profondità, l'esplorazione di un grafo di cui non sono preventivamente noti i vertici richiede la sostituzione dell'array r a g g i u n t o con un dizionario: valgono rispetto a ciò le considerazioni effettuate per la visita in ampiezza nel Paragrafo 7.4.1. Nel caso specifico del grafo del Web, possiamo sostituire la coda o la pila con una coda che estrae gli elementi in base a un loro valore di rilevanza (il rank delle pagine Web), garantendo in questo modo la priorità di caricamento, durante la visita, alle pagine classificate come più interessanti. ALVIE:

visita in profondità di un grafo Osserva, s p e r i m e n t a e v e r i f i c a DepthFirstSearch

7.5 7.5.1

Applicazioni delle visite di grafi Grafi diretti aciclici e ordinamento topologico

La visita in profondità trova applicazione, tra l'altro, nell'identificazione dei cicli in un grafo, che in tal caso viene detto ciclico, mentre è aciclico se non contiene cicli: vale infatti la proprietà che un grafo G è ciclico se e solo se contiene almeno un arco all'indietro

(definito per le visite BFS e DFS). Infatti, consideriamo un grafo con un arco all'indietro (u, v) che, ricordiamo, non appartiene all'albero di ricoprimento (BFS o DFS) di G: esiste un cammino da v a u nell'albero in quanto, per definizione di arco all'indietro, v è antenato di u e da ciò deriva che, estendendo questo cammino con (u,v), ritorniamo in v, ottenendo quindi un ciclo. Viceversa, consideriamo un grafo contenente un ciclo: la visita costruisce un albero DFS che non può contenere tutti gli archi del ciclo, in quanto un albero è aciclico, e quindi almeno un arco è all'indietro. L'argomentazione suddetta vale per grafi orientati e non; infatti, nel caso di grafi orientati, se un ciclo contiene un arco in avanti (u,v) allora possiamo sostituire tale arco con il cammino da u a v nell'albero e ottenere comunque un ciclo (ricordiamo che, nel caso di grafi orientati, gli archi nell'albero sono diretti dai padri ai figli). Quindi, se il grafo è ciclico, esiste necessariamente un ciclo che non include archi in avanti. Infine, un arco trasversale (u,v) non può appartenere a un ciclo. Se così fosse, nell'albero il nodo u sarebbe antenato di v o viceversa, pervenendo a una contraddizione. L'algoritmo per verificare se un grafo è aciclico richiede 0 ( n + m) tempo: per ottenerlo, è infatti sufficiente modificare la visita in profondità (aggiungendo un ramo ELSE al controllo nella riga 7 del Codice 7.8 o nella riga 5 del Codice 7.9) in modo che, se essa trova che un vertice è già stato scoperto, determina che l'arco (u, v) è all'indietro e quindi che il grafo contiene un ciclo. Un grafo orientato aciciclo è chiamato DAG {Directed Acyclic Graph) e viene utilizzato in quei contesti in cui esiste una dipendenza tra oggetti espressa da una relazione d'ordine: per esempio gli esami propedeutici in un corso di studi, la relazione di ereditarietà tra classi nella programmazione a oggetti, la relazione tra ingressi e uscite delle porte in un circuito logico, oppure l'ordine di valutazione delle formule in un foglio elettronico. In generale, supponiamo di avere decomposto un'attività complessa in un insieme di attività elementari e di avere individuato le relativa dipendenze. Un esempio concreto potrebbe essere la costruzione di un'automobile: volendo eseguire sequenzialmente le attività elementari (per esempio, in una catena di montaggio), bisogna soddisfare il vincolo che, se l'attività B dipende dall'attività A, allora A va eseguita prima di B. Usando i DAG per modellare tale situazione, poniamo i vertici in corrispondenza biunivoca con le attività elementari, e introduciamo un arco (A,B) per indicare che l'attività A va eseguita prima dell'attività B. Un'esecuzione in sequenza delle attività che soddisfi i vincoli di precedenza tra esse, corrisponde a un ordinamento topologico del DAG costruito su tali attività, come illustrato nella Figura 7.4. Dato un DAG G = (V, E), un ordinamento topologico di G è una numerazione r| : Vi-» { 0 , 1 , . . . , n — 1} dei suoi vertici tale che per ogni arco (u,v) e E vale r|(u) < r|(v). In altre parole, se disponiamo i vertici lungo una linea orizzontale in base alla loro numerazione T|, in ordine crescente, otteniamo che gli archi risultano tutti orientati da sinistra verso destra. L'ordinamento topologico può anche essere visto come

© ® ©

©

©

( è " " © " ® ti

0

1

2

3

4

5

® Figura 7.4

Un esempio di DAG e di suo ordinamento topologico.

un ordinamento totale compatibile con l'ordinamento parziale rappresentato dal DAG. Osserviamo che i grafi ciclici non hanno un ordinamento topologico. Concettualmente, l'ordinamento topologico di un DAG G può essere trovato come segue: prendiamo un vertice z avente grado di uscita nullo, ovvero tale che la sua lista di adiacenza è vuota (tale vertice deve necessariamente esistere, altrimenti G sarebbe ciclico). Assegniamo il valore r|(z) = n — 1 a tale vertice, rimuovendolo quindi da G insieme a tutti i suoi archi entranti, ottenendo così un grafo residuo G ' che sarà ancora un DAG. Identifichiamo ora un vertice z' di grado di uscita nullo in G', a cui assegniamo q(z') = n — 2, rimuovendolo come descritto sopra. Iterando questo procedimento, otteniamo alla fine un grafo residuo con un solo vertice s, a cui assegniamo numerazione ri(s) = 0. Ogni arco (u,v) è evidentemente orientato da sinistra a destra nell'ordinamento indotto da rj, semplicemente perché v viene rimosso prima di u per cui q(v) > T|(u). Da tale procedimento deduciamo, inoltre, che non è detto che esista un unico ordinamento topologico per un dato DAG, in quanto, in generale, in un dato istante possono esistere più nodi aventi grado di uscita nullo, e quindi più possibilità (tutte corrette) di scelta del nodo da rimuovere. L'algoritmo per trovare un ordinamento topologico, in realtà, può essere realizzato in modo semplice, come mostrato nel Codice 7.10. Esso si basa sulla visita ricorsiva in profondità discussa precedentemente nel Codice 7.9: tale visita viene estesa realizzando la funzione TI(u) mediante un array e t à [u] e un contatore globale, inizializzato a n — 1 (riga 4 dell'ordinamento topologico). Dopo che le visite lungo gli archi uscenti da u sono terminate, il contacore viene assegnato a e t a [ u ] e decrementato di uno (righe 7 - 8 della visita ricorsiva). Intuitivamente, tutti i vertici raggiungibili da u in uscita sono stati esaminati e hanno ricevuto una numerazione strettamente maggiore del valore corrente del contatore, per cui assegnando tale valore a e t a [ u ] garantiamo che valga eta[u] < eta[u] per ogni arco uscente (u, v). Per garantire di assegnare una numerazione a tutti i vertici, scandiamo l'insieme dei vertici stessi, invocando la visita ricorsiva su quelli non ancora raggiunti dalle visite precedenti.

Ordinamento-topologico ( ): FOR (s = 0; s < n; s = s + 1) raggiunto[s] = FALSE; contatore = n - 1 ; FOR (S = 0; s < n; s = s + 1) { IF (!raggiunto[s]) DepthFirstSearchRicorsivaOrdinaC s );

> DepthFirstSearchRicorsivaOrdinaC u ): raggiunto[u] = TRUE; FOR (X = listaAdiacenza[u].inizio; x != nuli; x = x.succ) { v = x.dato; IF (!raggiunto[v]) DepthFirstSearchRicorsivaOrdina( v );

> eta[u] = contatore; contatore = contatore - 1; Codice 7.10 Ordinamento topologico di un grafo diretto aciclico. Per ogni vertice, l'array età indica l'ordine inverso di terminazione della visita in profondità ricorsiva.

Il costo computazionale rimane 0 ( n + m) tempo e lo spazio occupato è O(n) celle di memoria, richieste dalla pila implicitamente gestita dalla ricorsione. ALVIE:

ordinamento topologico di un grafo Osserva, sperimenta e verifica TopologicalSort

7.5.2

Componenti (fortemente) connesse

Le visite di grafi sono utili anche per individuare le componenti connesse di un grafo non orientato. Riconsiderando la scansione effettuata nel Codice 7.9 da questo punto di vista, notiamo che tutti i vertici sono connessi se e solo se, al termine della visita, tutti i vertici risultano raggiunti. Ne deriva che, in tal caso, tutti i valori dell'array r a g g i u n t o sono TRUE dopo la terminazione di S c a n s i o n e . Se, al contrario, qualche vertice non risulta raggiunto, esso verrà esaminato successivamente nel corso della visita ricorsiva invocata su un qualche nodo s / 0: ogni qualvolta abbiamo che r a g g i u n t o [ s ] vale FALSE, viene individuata una nuova componente connessa, che include il nodo s. L'individuazione

d

a

1 Figura 7.5

Un esempio di grafo orientato con le sue componenti fortemente connesse.

delle componenti connesse in un grafo orientato richiede pertanto 0 ( n + m) tempo e O(n) celle di memoria. Nel caso di un grafo orientato, come il grafo del Web, le componenti fortemente connesse sono collegate alla nozione di navigatore casuale (Paragrafo 6.4): osserviamo però che, se il grafo ha più di una componente fortemente connessa, il navigatore casuale rischia di non poter più raggiungere tutte le pagine perché resta intrappolato in una delle componenti. Tale eventualità viene scongiurata introducendo la possibilità per il navigatore di scegliere la prossima pagina in modo casuale. Per individuare le componenti fortemente connesse in un grafo orientato G = (V, E) applichiamo a G una visita in profondità ottenendo, come vedremo, una partizione dell'insieme dei vertici V in sottoinsiemi Vo, V i , . . . , V s ^i massimali e disgiunti, e tale che ciascun sottoinsieme Vi soddisfa la proprietà che due qualunque vertici u , v G V; sono collegati da un cammino orientato sia da u a v che da v a u (mentre questa proprietà non vale se u G Vi e v e Vj per i ^ j). Un semplice esempio di grafo composto da una singola componente fortemente connessa è dato da un ciclo orientato di vertici, oppure da un grafo contenente un ciclo Euleriano (che, ricordiamo, attraversa tutti gli archi una e una sola volta). Un esempio di grafo composto da più componenti è invece mostrato nella Figura 7.5, dove le componenti (massimali) sono racchiuse in cerchi per scopo illustrativo. Le componenti possono essere anche viste come macro-vertici, collegati da archi multipli.

S = T0

U

Figura 7.6

Passo generico dell'algoritmo per l'individuazione delle componenti fortemente connesse: quelle complete sono indicate in grigio chiaro mentre quelle parziali, attraversate dal cammino n dal vertice s al vertice u, sono rappresentate in neretto (quelle isolate non sono mostrate). I vertici nelle componenti parziali sono di tre tipi: quelli lungo 7i (in neretto), quelli con la visita completata (in grigio scuro) e quelli ancora da scoprire (in girgio chiaro). I rappresentanti sono indicati con r 0 =

Un'importante proprietà è che, non considerando la molteplicità di tali archi, i macrovertici formano un DAG: se così non fosse, infatti, un ciclo di macro-vertici formerebbe una componente fortemente connessa più grande, in quanto due vertici arbitrari all'interno di due macro-vertici distinti sarebbero comunque collegati da cammini in entrambe le direzioni, ma questo non è possibile per la massimalità delle componenti. Il DAG ottenuto in questo modo a partire dall'esempio mostrato nella Figura 7.5 è rappresentato nella Figura 7.4. La strutturazione di un grafo orientato in un DAG di macro-vertici (corrispondenti a componenti fortemente connesse) è fondamentale per la comprensione dell'algoritmo che stiamo per discutere. Un'altra utile osservazione riguarda la visita ricorsiva in profondità mostrata nel Codice 7.9. Ricordiamo che la visita mantiene implicitamente, e in ordine inverso, il cammino ti nell'albero DFS dal nodo di partenza s al vertice u attualmente considerato nella visita: i vertici lungo 7t sono quelli in cui la visita ricorsiva è iniziata ma non ancora terminata. I rimanenti vertici ricadono in due tipologie, ovvero quelli la cui visita è stata già completata (quindi la chiamata ricorsiva per loro è terminata) oppure quelli che non sono stati ancora raggiunti.

Per individuare le componenti fortemente connesse, applichiamo un algoritmo basato sulla visita ricorsiva in profondità, che si avvale anche di due ulteriori pile di vertici. Consideriamo un istante qualunque nell'esecuzione dell'algoritmo, e sia u il vertice attualmente raggiunto dalla visita. Adottiamo la seguente terminologia per classificare le componenti fortemente connesse del grafo in base allo stato dei vertici in esse contenuti rispetto alla visita in corso, oltre che al cammino implicito n dal vertice di partenza s al nodo u: • una componente è completa se la visita in tutti i suoi vertici è stata completata (tali vertici vengono detti completi e la visita ricorsiva in essi è terminata); • una componente è parziale se contiene alcuni vertici del cammino 71 (oltre a questi può contenere gli altri due tipi di vertici, ossia quelli la cui visita è stata già completata e quelli che non sono stati ancora raggiunti): sono chiamati parziali tutti i vertici della componente tranne quelli non ancora raggiunti; • una componente è ignota altrimenti, ovvero contiene esclusivamente vertici che non sono stati ancora raggiunti. L'algoritmo identifica anche dei rappresentanti durante la visita. Precisamente, un vertice parziale u è un rappresentante della propria componente (parziale) se è il primo vertice della componente a essere visitato. Quando la componente diventa completa, il rappresentante diventa completo come il resto dei vertici in essa e perde il suo status di rappresentante. Di conseguenza, i rappresentanti sono nel cammino n e separano una componente parziale dalla successiva. Se numeriamo tutti i vertici nell'ordine di scoperta da parte della visita (usando un array df sNumero a tal fine), i rappresentanti compaiono in ordine crescente di numerazione lungo il cammino 7t, come mostrato nella Figura 7.6. Durante la visita, l'algoritmo mantiene due pile: • p a r z i a l i : contiene tutti i vertici parziali inseriti in ordine di visita; • r a p p r e s e n t a n t i : contiene i vertici rappresentanti inseriti in ordine di visita. In generale, presi i vertici contenuti nel cammino 7t, osserviamo che i vertici parziali ne sono un sovrainsieme mentre i rappresentanti ne sono un sottoinsieme. Inoltre, i vertici appartenenti a una stessa componente parziale occupano posizioni contigue nella pila p a r z i a l i e il primo di tali vertici a essere impilato è il loro rappresentante, che viene anche inserito in r a p p r e s e n t a n t i a tale scopo. Queste sono le proprietà che il Codice 7.11 intende mantenere e utilizzare per l'individuazione delle componenti fortememente connesse. Inizialmente, nessun vertice è ancora esaminato (e quindi neanche c o m p l e t o ) e le pile sono vuote. Inoltre, usiamo l'array df sNumero sia per numerare i vertici in ordine di scoperta (attraverso c o n t a t o r e )

ComponentiFortementeConnesse( ): FOR (s = 0; s < n; s = s + 1) { dfsNumero[s] = -1; completo[s] = FALSE;

> contatore = 0; FOR (s = 0; s < n; s = s + 1) { IF (dfsNumero [s] == -1) DepthFirstSearchRicorsivaEstesa( s );

> DepthFirstSearchRicorsivaEstesa( u ): df sNumero[u] = contatore; contatore = contatore + 1; parziali.Push( u ); rappresentanti.Push( u ); FOR (X = listaAdiacenza[u].inizio; x != nuli; x = x.succ) { v = x.dato; IF (dfsNumero [v] == -1) { DepthFirstSearchRicorsivaEstesa( v ); > ELSE IF (!completo[v]) {

WHILE (dfsNumero[rappresentanti.Top()] > dfsNumero[v]) rappresentanti .PopO ;

> > IF (u == rappresentanti.TopO) { PRINT 'Nuova componente fortemente connessa:' DO {

PRINT z = parziali .PopO ; completo[z] = TRUE; > WHILE (z != u);

rappresentanti .PopO ;

> Codice 7.11

Stampa delle componenti fortemente connesse in un grafo orientato.

s = r0

Figura 7.7

s = r0

Situazione trattata dalle righe 10-12 di D e p t h F i r s t S e a r c h R i c o r s i v a E s t e s a ( u ) , prima (a sinistra nella figura) e dopo (a destra) la loro esecuzione.

sia per stabilire se un vertice è stato visitato o meno: inizializzando gli elementi di tale array al valore — 1, il successivo assegnamento di un valore maggiore oppure uguale a 0 (a seguito della visita) ci permette di stabilire se il corrispondente vertice sia stato raggiunto o meno. Osserviamo che, a differenza della visita in profondità, non occorre utilizzare esplicitamente l'array r a g g i u n t o . Le righe 2 - 3 assegnano la numerazione di visita a u, e le successive righe 4 - 5 inseriscono u in cima a entrambe le pile (in quanto potrebbe iniziare una nuova componente parziale che prima era ignota). A questo punto, esaminiamo la lista dei vertici adiacenti di u e invochiamo ricorsivamente la visita su quei vertici non ancora raggiunti (righe 8 9). Al contrario delle visite discusse in precedenza, se un vertice v adiacente a u è stato raggiunto precedentemente (righe 10-12), occorre verificare se l'arco (u, v) contribuisce alla creazione di un ciclo. Questo è possibile solo se v non è completo (riga 10): altrimenti (u, v) è un arco del DAG di macro-vertici di cui abbiamo discusso prima e non può creare un ciclo. Ipotizzando quindi che v non sia completo, siamo nella situazione mostrata nella Figura 7.7, dove l'arco (u,v) chiude un ciclo di componenti parziali, che devono essere unite in una singola componente parziale. Poiché i rispettivi vertici parziali occupano posizioni contigue nella pila p a r z i a l i , è sufficiente rimuovere i soli rappresentanti di tali componenti dalla pila r a p p r e s e n t a n t i : ne sopravvive solo uno, ovvero quello con numerazione di visita minore, che diventa il rappresentante della nuova componente

s = r0

•

Figura 7.8

s = T0

• "

Situazione trattata dalle righe 17-20 di D e p t h F i r s t S e a r c h R i c o r s i v a E s t e s a ( u ) , prima (a sinistra nella figura) e dopo (a destra) la loro esecuzione.

parziale così creata implicitamente (righe 10-12, dove la numerazione di v è usata per eliminare i rappresentanti che non sopravvivono). Terminata la scansione della lista di adiacenza di u, e le relative chiamate ricorsive, abbiamo che u diventa completo perché non possiamo scoprire ulteriori vertici tramite esso. Se u è anche rappresentante della propria componente (riga 15), vuol dire che u e tutti i vertici parziali che si trovano sopra di esso in p a r z i a l i formano una nuova componente completa, come illustrato nella Figura 7.8. E sufficiente, quindi, estrarre ciascuno di tali vertici dalla pila p a r z i a l i , marcarlo come c o m p l e t o (righe 18—19) ed eliminare u dalla pila r a p p r e s e n t a n t i (riga 21): notiamo che il corpo del ciclo alle righe 17-20 viene eseguito prima della guardia che, se non verificata, fa uscire dal ciclo. Inoltre, ogni vertice viene inserito ed estratto una sola volta al più in ciascuna pila, per cui il costo asintotico rimane quello della visita ricorsiva, ovvero 0 ( n + m) tempo e O(n) celle di memoria. ALVIE:

componenti (fortemente) connesse di un grafo

Osserva, sperimenta e verifica

Conne etedComponent

RIEPILOGO In questo capitolo abbiamo esaminato le pile e le code, mostrando come applicarle alla valutazione di notazioni polacche e a diversi problemi su grafi: visite in ampiezza e profondità, verifica della ciclicità o meno di un grafo, ordinamento topologico di un grafo aciclico, calcolo delle componenti (fortemente) connesse. ESERCIZI 1. Scrivete il codice per realizzare la conversione e l'interprete per le espressioni polacche. Usate un spazio bianco per separare variabili e costanti. 2. Scrivete il codice per implementare una coda mediante una lista, secondo quanto descritto nel Paragrafo 7.3.2. 3. Modificate la tabella di conversione da un'espressione infissa a una postfissa (Figura 7.1) in modo da riconoscere quando l'espressione infissa fornita in ingresso è sintatticamente incorretta (ad esempio, A + xB). 4. Modificate il codice per costruire l'albero BFS come albero ordinale rappresentato con memorizzazione binarizzata. 5. Usate la visita DFS per mostrare che un grafo non orientato con grado minimo d ammette un cammino di lunghezza maggiore di d. 6. Ricordiamo che il grafo a torneo è un grafo orientato G in cui per ogni coppia di vertici x e y esiste un solo arco che li collega, (x,y) oppure (y,x), ma non entrambi. L'interpretazione è che nella partita del torneo tra x e y uno dei due ha vinto. Prendete il DAG risultante dalle componenti fortemente connesse (che sono i macro-vertici) e mostrate che l'ordinamento topologico del DAG induce una classifica dei partecipanti al torneo.

Capitolo 8

Code con priorità

SOMMARIO In questo capitolo illustriamo e analizziamo la struttura di dati denominata coda con priorità, che gestisce sequenze di inserimenti ed estrazioni di elementi da un insieme, in presenza di pesi associati a tali elementi, pesi che ne determinano l'ordine di estrazione dall'insieme stesso. Di tale struttura di dati presentiamo l'implementazione più diffusa, lo heap, mostrandone poi l'utilizzo in contesti informatici diversi, quali l'ordinamento, la ricerca di cammini minimi su grafi pesati e l'individuazione di alberi ricoprenti di peso minimo (sempre su grafi pesati). DIFFICOLTÀ 1,5 CFU

8.1

Code con priorità

La struttura di dati coda con priorità memorizza una collezione di elementi in cui a ogni elemento è associato un valore, detto peso, appartenente a un insieme totalmente ordinato (solitamente l'insieme degli interi positivi). La coda con priorità può essere vista come un'estensione della coda (Paragrafo 7.3) e, infatti, le operazioni disponibili sono le stesse della coda: Empty, Enqueue, F i r s t e Dequeue. L'unica e sostanziale differenza rispetto a tale tipo di dati è che le ultime due operazioni devono restituire (ed estrarre, nel caso della Dequeue) l'elemento di peso minimo nella coda con priorità. 1 Ai fini della discussione, ipotizziamo che ciascun elemento e memorizzato nella coda con priorità contenga due campi, ossia un campo e . p e s o per indicarne il peso e un campo e . d a t o per indicare i dati a cui associare quel peso. 'Nel seguito, considereremo il caso in cui la coda con priorità restituisce sempre il minimo, ma le stesse considerazioni possono essere applicate mutatis mutandis al caso in cui dobbiamo restituire il massimo.

La necessità di estrarre gli elementi dalla coda in funzione del loro peso, ne rende l'implementazione più complessa rispetto a quella della semplice coda. Per convincerci di ciò consideriamo la semplice implementazione di una coda con priorità mediante una lista dei suoi elementi. Nel caso in cui decidiamo di implementare in tempo costante l'operazione Enqueue, inserendo i nuovi elementi in corrispondenza a un estremo della lista, ne deriva che la lista non è ordinata: per l'implementazione di Dequeue e di F i r s t è necessario individuare l'elemento di peso minimo all'interno della lista e, quindi, tale operazione richiede tempo O(n), dove n è la lunghezza della lista. Ad esempio, facendo riferimento alla parte alta della Figura 8.1, l'inserimento nella lista di un nuovo elemento avviene ponendolo subito prima del primo (con peso pari a 17), mentre la Dequeue richiede la scansione dell'intera lista, per determinare che l'elemento minimo è quello con peso pari a 3 e per poi estrarlo. Se decidiamo, invece, di mantenere gli elementi della lista ordinati rispetto al loro peso (ad esempio, in ordine non decrescente), ne deriva che Dequeue e F i r s t richiedono 0(1) tempo, in quanto l'elemento di peso minimo è sempre il primo della lista. Al tempo stesso, però, in corrispondenza a ogni Enqueue dobbiamo utilizzare tempo 0 ( n ) per inserire il nuovo elemento nella giusta posizione della lista, corrispondente all'ordinamento degli elementi nella lista stessa. Ad esempio, facendo riferimento alla parte bassa della Figura 8.1, osserviamo che l'operazione Dequeue richiede soltanto di eliminare il primo elemento della lista (ovvero, quello con pes^ pari a 3). L'esecuzione della Enqueue, ad esempio di un elemento con peso pari a 16, richiede però la scansione di una parte della lista per determinare che l'elemento va inserito tra gli elementi con pesi pari a 15 e 17: nel caso peggiore, la scansione avviene sull'intera lista. Facendo uso di soluzioni più sofisticate è possibile implementare una coda con priorità in modo più efficiente, in tempo O(logn), attraverso un bilanciamento del costo di esecuzione delle operazioni Dequeue e Enqueue, ottenuto per mezzo di un'organizzazione dell'insieme degli elementi in cui questi siano ordinati solo in parte.

Figura 8.2

8.2

Heaptree (a sinistra) e albero che non soddisfa la proprietà di heap (a destra).

Heap

Uno heap è una struttura di dati che, attraverso una rappresentazione solo parzialmente ordinata dei suoi elementi, permette di ottenere un tempo logaritmico per le operazioni E n q u e u e e Dequeue e un tempo costante per le operazioni Empty e F i r s t . Lo heap presenta la caratteristica di essere un albero binario completo a sinistra, di cui possiamo quindi dare una rappresentazione implicita (Paragrafo 4.3.1). Almeno inizialmente, comunque, descriveremo la sua struttura facendo riferimento a un'organizzazione esplicita ad albero, detta heaptree, degli elementi stessi: mostreremo poi come tale organizzazione possa essere riportata in termini della rappresentazione implicita. Uno heaptree è un albero H che soddisfa la seguente proprietà di heap (minimo): 1. il peso dell'elemento contenuto nella radice di H è minore o uguale di quelli contenuti nei figli della radice; più precisamente, se r è la radice di H e Vo, V i , . . . , v ^ - j sono i suoi figli, allora r . p e s o ^ v t . p e s o , per 0 ^ i < k.; 2. l'albero radicato in Vi è uno heaptree per 0 ^ i < k (gli alberi vuoti sono heaptree). L'albero nella parte sinistra della Figura 8.2 è uno heaptree, a differenza di quello nella parte destra in cui, ad esempio, il nodo con peso 18 è sopra al nodo con peso 14. Come corollario immediato, abbiamo che la radice di uno heaptree contiene l'elemento di peso minimo dell'insieme. Di conseguenza, l'effettuazione dell'operazione F i r s t nel caso di una coda con priorità implementata con uno heaptree richiede 0 ( 1 ) tempo. Uno heap è uno heaptree con i vincoli aggiuntivi di essere binario e completo a sinistra: ovvero, se h. è la sua altezza, i nodi di profondità minore di h. formano un albero completamente bilanciato e quelli di profondità h. sono tutti accumulati a sinistra. L'albero nella parte sinistra della Figura 8.3 è uno heap, mentre quello nella parte destra,

Figura 8.3

Heap (a sinistra) e heaptree che non e uno heap (a destra).

pur essendo uno heaptree, non è uno heap in quanto non è completo a sinistra. Nel Paragrafo 4.3.1 abbiamo visto che un albero completo a sinistra con n nodi ha altezza pari a h. = O(logn): ciò ci consente di effettuare in tempo O(logn) le operazioni Enqueue e Dequeue, di cui forniamo uno schema algoritmico generale mostrando poi come realizzare tali algoritmi nel contesto specifico della rappresentazione implicita. L'effettuazione dell'operazione Enqueue di un elemento e in uno heap H prevede, ad alto livello, l'esecuzione dei seguenti passi. 1. Inseriamo un nuovo nodo v contenente e come foglia di H in modo da mantenere H completo a sinistra. 2. Iterativamente, confrontiamo il peso di e con quello dell'elemento f contenuto nel padre di v e, se e.peso < f . p e s o , i due nodi vengono scambiati: l'iterazione termina quando v diventa la radice oppure quando e.peso ^ f . p e s o (notiamo che in questo modo manteniamo la proprietà di uno heaptree). Come possiamo vedere, l'operazione Enqueue opera inserendo un elemento nella sola posizione che consente di preservare la completezza a sinistra dello heap, facendo poi risalire l'elemento nello heap, di figlio in padre, fino a trovare una posizione che soddisfi la proprietà di uno heaptree. L'operazione Enqueue implementata su uno heap richiede tempo O(logn): a tal fine, ci basta osservare che il numero di passi effettuati è proporzionale al numero di elementi con i quali e viene confrontato e che tale numero è al massimo pari all'altezza h. = O(logn) dello heap (in quanto e viene confrontato con al più un elemento per ogni livello dello heap). Passiamo a considerare ora l'operazione Dequeue, che può essere effettuata, sempre ad alto livello, su uno heap H nel modo seguente.

1. Estraiamo la radice di H in modo da restituire l'elemento in essa contenuto alla fine dell'operazione. 2. Rimuoviamo l'ultima foglia di H (quella più a destra nell'ultimo livello), per inserirla come radice v (al posto di quella estratta), al fine di mantenere H completo a sinistra. 3. Iterativamente, confrontiamo il peso dell'elemento in v con quelli degli elementi nei suoi figli e, se il minimo fra i tre pesi non è quello di v, il nodo v viene scambiato con il figlio contenente l'elemento di peso minimo: l'iterazione termina se v diventa una foglia o se contiene un elemento il cui peso è minore di quelli degli elementi contenuti nei suoi figli. Al contrario dell'operazione Enqueue, l'operazione Dequeue opera facendo scendere un elemento, impropriamente posto come radice, all'interno dello heap, fino a soddisfare la proprietà di uno heaptree. Applicando le stesse considerazioni effettuate nel caso dell'operazione Enqueue, possiamo verificare che l'operazione Dequeue implementata su uno h^ap richiede anch'essa tempo O(logn). Notiamo che invertendo l'ordine dei confronti effettuati possiamo gestire uno heap H che soddisfa la proprietà di massimo nei suoi nodi (anziché di minimo), in cui il massimo è nella radice.

8.2.1

Implementazione di uno heap implicito

Come dichiarato sopra, uno heap è un albero completo a sinistra e, per quanto osservato nel Paragrafo 4.3.1, gode dell'interessante proprietà di poter essere rappresentato in modo implicito per mezzo di un array, che indichiamo con h e a p A r r a y , senza fare uso di riferimenti espliciti tra i nodi. Ricordiamo che i nodi dello heap H corrispondono agli elementi di h e a p A r r a y come segue: 1. la radice di H corrisponde all'elemento heapArray[0]; 2. se un nodo v di H corrisponde all'elemento heapArray[i], allora il figlio sinistro corrisponde all'elemento h e a p A r r a y [ 2 i + 1], il figlio destro corrisponde a h e a p A r r a y [ 2 i + 2] e il padre corrisponde a h e a p A r r a y [ ( i — 1 )/2]. Come effetto di questa rappresentazione, se H ha n nodi, i corrispondenti elementi sono memorizzati in ordine di ampiezza nelle prime n posizioni di h e a p A r r a y ed è possibile attraversare l'albero da padre a figlio o viceversa, in tempo costante. Dato che gli elementi dello heap occupano la parte iniziale di h e a p A r r a y , nell'implementazione è necessario prevedere anche una variabile intera h e a p S i z e , che indichi

Empty( ): RETURN heapSize == 0;

First( ): IF (!Empty( )) RETURN heapArray[0]; Enqueue( e ): VerificaRaddoppio( ); heapArray[heapSize] = e; heapSize = heapSize + 1 ; RiorganizzaHeapC heapSize - 1 ); Dequeue( ): IF (!Empty( )) { minimo = heapArray[0]; heapArray[0] = heapArray[heapSize - 1]; heapSize = heapSize - 1; RiorganizzaHeapC 0 ); VerificaDimezzamento( ); RETURN minimo;

} Codice 8.1

Implementazione di uno heap mediante un array: le funzioni Verif icaRaddoppio e VerificaDimezzamento seguono l'approccio del Paragrafo 2.1.3.

il numero di elementi attualmente presenti nello heap: in altre parole, h e a p S i z e è l'indice della prima posizione libera di h e a p A r r a y . Consideriamo ora l'implementazione, riportata nel Codice 8.1, delle quattro operazioni fornite da una coda con priorità. Possiamo osservare, per prima cosa, che la funzione Empty restituisce il valore t r u e se e solo se h e a p S i z e è uguale a 0 mentre, se lo heap non è vuoto, la funzione F i r s t restituisce il primo elemento di h e a p A r r a y che, per la rappresentazione implicita sopra illustrata, corrisponde alla radice dello heap. L'operazione E n q u e u e verifica se l'array debba essere raddoppiato (riga 2): successivamente, inserisce il nuovo elemento nella prima posizione libera dell'array e, quindi, come foglia dello heap per mantenerne la completezza a sinistra (riga 3). Dopo aver aggiornato il valore di h e a p S i z e (riga 4), per mantenere la proprietà di uno heaptree viene invocata la funzione R i o r g a n i z z a H e a p (riga 5), di cui posponiamo la discussione. Se lo heap contiene almeno un elemento, l'operazione D e q u e u e determina quello con il minimo peso, ovvero quello che si trova nella posizione iniziale dell'array (riga 3): quindi, per mantenere la completezza a sinistra, copia nella prima posizione l'elemento

RiorganizzaHeap ( i ): {pre: heapArray è uno heap tranne che nella posizione i) WHILE (i>0 kk heapArray[i].peso < heapArray[Padre(i)].peso) { Scambiai i, Padre( i ) ); i = Padre( i );

> WHILE (Sinistro(i) < heapSize kk i != MinimoPadreFigii(i)) { figlio = MinimoPadreFigli( i ); Scambia( i, figlio ); i = figlio;

> MinimoPadreFigli ( i ) : {pre: il nodo in posizione i ha almeno un figlio) j = k = Sinistro(i); IF (k+1 < heapSize) k = k+1; IF (heapArray[k].peso < heapArray[j].peso) j = k; IF (heapArray[i].peso < heapArraytj].peso) j = i; RETURN J; Padre(

1 ):

RETURN (i-l)/2; Sinistro( i ): RETURN 2 x i + 1;

Codice 8.2

Scambiai i, j ): tmp=heapArray[i]; heapArray[i]=heapArray[j]; heapArray[j]=tmp;

Riorganizzazione di uno heap per mantenere la proprietà di uno heaptree.

che si trova nella posizione finale e che corrisponde all'ultima foglia dello heap, e aggiorna il valore di h e a p S i z e (righe 4 e 5). Infine, per mantenere la proprietà di uno heaptree, invoca R i o r g a n i z z a H e a p e verifica se l'array debba essere dimezzato (righe 6 e 7). La funzione R i o r g a n i z z a H e a p , riportata nel Codice 8.2, ripristina la proprietà di uno heaptree in un albero completo a sinistra e rappresentato in modo implicito, con l'ipotesi che l'elemento e = h e a p A r r a y [ i ] sia eventualmente l'unico a violare la proprietà di heaptree. Il primo ciclo viene eseguito quando e deve risalire lo heap perché e . p e s o è minore del peso di suo padre: dobbiamo quindi scambiare e con il padre e iterare (righe 2-5). Il secondo ciclo viene eseguito quando e deve scendere perché e . p e s o è maggiore del peso di almeno uno dei suoi figli: dobbiamo quindi scambiare e con il figlio avente peso minimo, in modo da far risalire tale figlio e preservare la proprietà di uno heaptree (righe 6—10). Tale eventualità è segnalata nella riga 6 dal fatto che M i n i m o P a d r e F i g l i non restituisce i come posizione dell'elemento di peso minimo tra e e i suoi figli (que-

sto vuol dire che un figlio ha peso strettamente minore poiché, a parità di peso, viene restituito i). Il codice relativo a M i n i m o P a d r e F i g l i tiene conto dei vari casi al contorno che si possono presentare (per esempio, che e abbia un solo figlio, il quale deve essere sinistro e deve essere l'ultima foglia). Notiamo che, per ogni posizione i nello heap e ogni elemento e = h e a p A r r a y [ i ] , non può mai accadere che vengano eseguiti entrambi i cicli di R i o r g a n i z z a H e a p : in altre parole, e sale con il primo ciclo o scende con il secondo, oppure è già al posto giusto e, quindi, nessuno dei cicli viene eseguito. Ne deriva che il costo di R i o r g a n i z z a H e a p è proporzionale all'altezza dello heap e, quindi, richiede O(logn) tempo. ALVIE:

operazioni su uno heap implicito

Osserva, sperimenta e verifica

CD

HeapArray

La complessità di O(logn) tempo delle operazioni sulla coda con priorità heap sono determinate dal costo logaritmico di R i o r g a n i z z a H e a p e dal costo ammortizzato costante per operazione di V e r i f i c a R a d d o p p i o e V e r i f i c a D i m e z z a m e n t o : come sempre, nel caso in cui utilizziamo un array per rappresentare un insieme di elementi varianti nel tempo, prevediamo che la sua dimensione possa variare quando necessario, e in particolare possa essere raddoppiata o dimezzata secondo quanto già discusso nel Paragrafo 2.1.3 (se l'array ha dimensione prefissata, i costi finali sono al caso pessimo).

8.2.2

Insolito caso di DecreaseKey

Un'operazione molto utile negli heap è quella denominata D e c r e a s e K e y , che permette di diminuire il peso di un elemento memorizzato nello heap. Tuttavia, localizzare tale elemento all'interno di h e a p A r r a y richiede O(n) tempo senza una struttura di dati ausiliare. A tal fine, ipotizziamo che, presi gli n elementi in h e a p A r r a y , i loro campi d a t o siano distinti e formino una permutazione degli interi ( 0 , 1 , . . . , n — 1} (tale situazione occorre nel Paragrafo 8.3.2 dove utilizziamo D e c r e a s e K e y ) . Possiamo quindi introdurre un array p o s i z i o n e H e a p A r r a y di n interi che rappresentano le posizioni occupate in h e a p A r r a y dagli elementi memorizzati nello heap, ossia vale p o s i z i o n e H e a p A r r a y [ h e a p A r r a y [ i ] . d a t o ] = i per 0 ^ i < h e a p S i z e . L'adozione di questo array richiede ulteriori O(n) celle di memorie e quindi Io heap risultante non è più implicito (e non è conosciuta una semplice soluzione per renderlo

DecreaseKeyC dato, peso ): i = posizioneHeapArray[dato]; heapArray[i].peso = peso; RiorganizzaHeap( i ); Enqueue( e ) : VerificaRaddoppioC ); heapArray[heapSize] = e; posizioneHeapArray[ e.dato ] = heapSize; heapSize = heapSize + 1 ; RiorganizzaHeapC heapSize - 1 ); Scambiai i, j ): tmp=heapArray[i]; heapArray[i]=heapArray[j]; heapArray[j]=tmp; posizioneHeapArray[ heapArray[i].dato ] = i; posizioneHeapArray[ heapArray[j].dato ] = j; Codice 8.3

Riorganizzazione di uno heap per l'operazione DecreaseKey, che richiede l'introduzione dell'array posizioneHeapArray, della riga 4 in Enqueue e delle righe 5 e 6 in Scambia.

implicito), ma comunque tale heap rimane una struttura di dati semplice ed efficiente, in quanto fornisce l'operazione D e c r e a s e K e y in tempo O(logn). Per mantenere le informazioni aggiornate in p o s i z i o n e H e a p A r r a y , occorre modificare le operazioni E n q u e u e e S c a m b i a come riportato nel Codice 8.3. In particolare, registriamo la posizione di ogni nuovo elemento messo in coda (riga 4 in Enqueue) e scambiamo le posizioni analogamente a quanto succede per h e a p A r r a y (righe 5 e 6 in S c a m b i a ) : notiamo che la complessità di tali operazioni non cambia asintoticamente. Infine, l'operazione D e c r e a s e K e y accede all'elemento nella posizione indicata da p o s i z i o n e H e a p A r r a y , diminuisce il peso di tale elemento e applica R i o r g a n i z z a H e a p per preservare la proprietà di heap, in costo O(logn) utilizzando l'analisi discussa in precedenza.

8.2.3

Costruzione di heap e ordinamento

Proviamo ora a considerare il costo di costruzione di uno heap da un insieme dato di n elementi, inizialmente posti in h e a p A r r a y stesso: la soluzione immediata in tal caso comporta l'esecuzione di n operazioni E n q u e u e su uno heap inizialmente vuoto, come mostrato nel Codice 8.4. Notiamo che tale algoritmo di costruzione opera in loco e,

CreaHeapO : heapSize = 0; FOR (i = 0; i < n; i = i+1) { Enqueue( heapArray[i] );

> Codice 8.4

Costruzione di uno heap mediante Enqueue.

inoltre, quando E n q u e u e deve inserire l'elemento h e a p A r r a y [ i ] , le precedenti posizioni h e a p A r r a y [ 0 , i — 1] formano uno heap con h e a p S i z e = i, per i > 0. In conseguenza di ciò, al termine dell'ultima iterazione, l'intero array rappresenta uno heap. Quale sarà il costo complessivo della costruzione? Dato il costo logaritmico di E n q u e u e , avremo che il costo di costruzione sarà O ( n l o g n ) nel caso peggiore. Tale costo non è migliorabile asintoticamente a causa dell'operazione E n q u e u e , dato che il numero di confronti effettuati da essa su uno heap di k elementi è almeno pari a logk nel caso peggiore. In tal caso, il Codice 8.4 totalizza un numero di confronti limitato inferiormente da logk = l°g n !> s u c u ' possiamo applicare la doppia disuguaglianza dell'approssimazione di Stirling, in base alla quale abbiamo che V^n7tn n e" n + TiiiTT < n ! < \ / 2 n n n n e ~

n +

^

(8.1)

Di conseguenza, il numero di confronti eseguiti da n operazioni di E n q u e u e nel caso peggiore sarà almeno pari a log(n!) > ^ log2n7i + n l o g n — ^ n - y ^ + l " )

lo

8e

=

n

(nlogn)

Il motivo intuitivo di tale fenomeno è che, poiché tutti gli elementi salgono lungo lo heap, eventualmente fino alla radice, e poiché il numero di elementi su un livello cresce (in particolare raddoppia) a ogni livello, ne deriva che, eseguendo il Codice 8.4, molti elementi percorrono, nel caso peggiore, un cammino "lungo" fino alla radice. Sarebbe più conveniente, se la costruzione dello heap potesse avvenire spostando gli elementi verso il basso, non verso la radice ma verso le foglie: in questo caso, infatti, la maggior parte degli elementi, che tende già a trovarsi vicino alle foglie, percorrerebbe un cammino "breve". Mostriamo come tale intuizione conduca a un algoritmo di costruzione dello heap che richiede soltanto O(n) tempo. Il Codice 8.5 opera in tal modo, utilizzando R i o r g a n i z z a H e a p , in una versione ristretta al solo secondo ciclo (righe 6—10), indicata con R i o r g a n i z z a H e a p F i g l i perché procede esclusivamente verso i figli. Le iterazioni del Codice 8.5 scandiscono

CreaHeapMigliorato( ): heapSize = n; FOR (i = N-1; i >=0; i = i - 1) { RiorganizzaHeapFigli(i);

> Codice 8.5

Costruzione di uno heap mediante R i o r g a n i z z a H e a p F i g l i .

h e a p A r r a y all'indietro e, in effetti, la prima metà circa di tali iterazioni sono inutili perché non modificano tale array in quanto sono invocate sulle foglie dello heap. Le rimanenti operano sui nodi interni e, per ciascun nodo h e a p A r r a y [ i ] , tale nodo e i suoi discendenti formano uno heap tranne che nella posizione i, per cui vengono riposizionati da R i o r g a n i z z a H e a p F i g l i : a ogni istante, la parte finale dell'array rappresenta un insieme di heap che, man mano, vengono uniti insieme fino a ottenere un unico heap nell'intero array. Notiamo che anche questo algoritmo di costruzione dello heap è in loco. ALVIE:

costruzione di uno heap

Jhfej^ ^¡Ip^

Osserva, sperimenta e verifica

®

®

o

©

MakeHeap

Proviamo ora a convincerci che, in effetti, l'array risultante dall'applicazione del Codice 8.5 rappresenta uno heap. A tal fine, notiamo che al termine dell'iterazione i dell'algoritmo gli elementi in h e a p A r r a y [ i , n — 1] verificano la proprietà di heaptree, ossia h e a p A r r a y [ ( j — l ) / 2 ] < h e a p A r r a y [ j ] per 2i + 1 < j < TI: in conseguenza di ciò, per le posizioni i dei nodi interni (dove i < (n — 2)/2), possiamo vedere che h e a p A r r a y [ i , n— 1] codifica un insieme di i + 1 heap, ciascuno radicato in una posizione distinta di h e a p A r r a y [ i , 2i]. Supponiamo induttivamente che la proprietà suddetta sia verificata per l'iterazion e i + 1 e che, quindi, le posizioni delle radici siano quelle nell'intervallo [ i + l , 2 ( i + 1)]: durante l'iterazione i, R i o r g a n i z z a H e a p considera l'elemento h e a p A r r a y [ i ] e i due heap aventi radici in h e a p A r r a y [ 2 i + 1] e h e a p A r r a y [ 2 i + 2], al fine di ottenere un unico heap con radice in h e a p A r r a y [i]. Quindi, le radici nelle posizioni 2i + 1 e 2i + 2 sono assorbite nel nuovo heap che soddisfa la proprietà di heaptree, e la posizione i diventa una nuova radice, trasformando così l'intervallo delle radici da [Ì+ 1 , 2 ( i + 1)] a [i, 2i]. Al termine dell'algoritmo, quando

HeapSort ( a ) : {pre: la lunghezza di a è n) CreaHeapMigliore( ); FOR (heapSize = n-1; heapSize > 0; heapSize = heapSize - 1) { Scambiai heapSize, 0 ); RiorganizzaHeap( 0 );

> Codice 8.6

Ordinamento mediante heap di un array a.

i = 0, la proprietà di heaptree è verificata a partire dalla radice h e a p A r r a y [ 0 ] e l'intero array forma uno heap. Mostriamo ora che l'intera riorganizzazione dell'albero richiede un numero di confronti lineare nel numero di elementi. A tal fine, osserviamo che il numero di confronti complessivamente eseguiti è, nel caso peggiore, proporzionale alla somma delle altezze di tutti i sottoalberi. Dato l'albero completo a sinistra corrispondente allo heap di altezza h., consideriamo il suo completamento nell'ultimo livello di foglie in modo da ottenere concettualmente un albero completo di altezza h (se non lo è già): possiamo constatare che il Codice 8.5 non può impiegare minor tempo al caso pessimo su quest'ultimo albero. Precisamente, esso effettua n / 2 iterazioni sulle foglie, n / 4 iterazioni sui padri delle foglie, n / 8 iterazioni sui nonni e così via: in generale, effettua n / 2 ' + 1 iterazioni sui nodi di altezza pari a j, per 0 ^ j ^ h., e ciascuna iterazione richiede tempo proporzionale all'altezza stessa j. Ne deriva che il costo totale dell'algoritmo di costruzione è x pari t i / 2 ' + 1 ), che è limitata superiormente da 2 I j > i ( j x n / 2 ' ) = O(n), dove La costruzione dello heap può essere impiegata per ordinare un array di elementi. Infatti, l'utilizzo di una coda con priorità fornisce un semplice algoritmo di ordinamento: per ordinare un array di n elementi avendo a disposizione una coda con priorità PQ è sufficiente dapprima inserire gli elementi in PQ, effettuando n operazioni E n q u e u e , e quindi estrarli uno dopo l'altro, mediante n operazioni D e q u e u e . In tal modo, l'ordinamento richiede tempo O ( n l o g n ) . Tuttavia, questo costo può essere ridotto, anche se non in termini asintotici, usando uno heap con la proprietà di heaptree massimo (invece che minimo) e applicando il metodo di costruzione dello heap illustrato nel Codice 8.5 che, come visto, richiede tempo O(n) per creare lo heap a partire dall'array: ciò fornisce un costo complessivo di 0 ( n + n l o g n ) per l'algoritmo, che comunque asintoticamente è ancora O ( n l o g n ) . Il vantaggio dell'utilizzo di uno heap è che l'ordinamento viene effettuato in loco. Come possiamo infatti vedere nel Codice 8.6, l'algoritmo cosiddetto di Heapsort opera, dato

h e a p A r r a y da ordinare, prima riposizionando gli elementi di h e a p A r r a y in modo tale da costruire uno heap, e poi eliminando iterativamente il massimo elemento nello heap (in posizione 0), la cui dimensione è decrementata di 1, costruendo al tempo stesso la sequenza ordinata degli elementi di h e a p A r r a y a partire dal fondo. ALVIE:

ordinamento mediante heap

Osserva, sperimenta e verifica

© ® ®

© °

©

HeapSort

In particolare, all'iterazione i, l'elemento massimo estratto dallo heap (che a quel punto ha dimensione i ed è rappresentato dagli elementi in h e a p A r r a y [ 0 , i — 1]) viene inserito nella posizione i di h e a p A r r a y . AI termine di tale iterazione, abbiamo che gli elementi in h e a p A r r a y [ 0 , i— 1] formano uno heap e sono tutti di peso minore o uguale a quelli ordinati in h e a p A r r a y [ i , n — 1]: quando i = 0, risultano tutti in ordine.

8.3

Opus libri: routing su Internet e cammini minimi

Le reti di computer, di cui Internet è il più importante esempio, forniscono canali di comunicazione tra i singoli nodi, che rendono possibile lo scambio di informazioni tra i nodi stessi, e con esso l'interazione e la cooperazione tra computer situati a grande distanza l'uno dall'altro. Il Web e la posta elettronica sono, in questo senso, due applicazioni di grandissima diffusione che si avvalgono proprio di questa possibilità di comunicazione tra computer diversi. L'interazione di computer attraverso Internet avviene mediante scambio di informazioni suddivise in pacchetti: anche se la quantità d'informazione da passare è molto elevata, come ad esempio nel caso di trasmissione di documenti video, tale informazione viene suddivisa in pacchetti di dimensione fissa, che sono poi inviati in sequenza dal computer mittente al destinatario. Dato che i computer mittente e destinatario non sono direttamente collegati, tale trasmissione non coinvolge soltanto loro, ma anche un ulteriore insieme di nodi della rete, che vengono attraversati dai pacchetti nel loro percorso verso la destinazione. Il protocollo IP (Internet Protocol), che è il responsabile del recapito dei pacchetti al destinatario, opera secondo un meccanismo di packet switching, in accordo al quale ogni pacchetto viene trasmesso in modo indipendente da tutti gli altri nella sequenza. In questo senso, lo stesso pacchetto può attraversare percorsi diversi in dipendenza di mutate condizioni della rete, quali ad esempio sopravvenuti malfunzionamenti o sovraccarico di traffico in determinati nodi.

In quest'ambito, è necessario che nella rete siano presenti alcuni meccanismi che consentano, a ogni nodo a cui è pervenuto un pacchetto diretto a qualche altro nodo, di individuare una "direzione" verso cui indirizzare il pacchetto per avvicinarlo al relativo destinatario: nello specifico, se un nodo ha d altri nodi a esso collegati direttamente, il nodo invia il pacchetto a quello adiacente più vicino al destinatario. Questo problema, noto come instradamento (routing) dei messaggi viene risolto su Internet nel modo seguente: 2 nella rete è presente un'infrastruttura composta da una quantità di computer (nodi) specializzati per svolgere la funzione di instradamento; ognuno di tali nodi, detti router, è collegato direttamente a un insieme di altri, oltre che a numerosi nodi "semplici" che fanno riferimento a esso e che svolgono il ruolo di mittenti e destinatari finali delle comunicazioni. Ogni router mantiene in memoria una struttura di dati, che di solito è una tabella, detta tabella di routing, rappresentata in una forma compressa per limitarne la dimensione, che permette di associare a ogni nodo sulla rete, identificato in modo univoco dal corrispondente indirizzo IP, a 32 o 128 bit (a seconda che sia utilizzato IPv4 o IPv6), uno dei router a esso direttamente collegati. L'instradamento di un pacchetto p da un nodo u a un nodo v di Internet viene allora eseguito nel modo seguente: p contiene, oltre all'informazione da inviare a v (il carico del pacchetto), un'intestazione (header) che contiene informazioni utili per il suo recapito; la più importante di tali informazioni è l'indirizzo IP di v. Il mittente u invia p al proprio router di riferimento ri, il quale, esaminando lo header di p, determina se v sia un nodo con cui ha un collegamento diretto: se è cosi, t] recapita il pacchetto al destinatario, mentre, in caso contrario, determina, esaminando la propria tabella di routing, quale sia il router t2 a esso collegato cui passare il pacchetto. Questa medesima operazione viene svolta da T2, e così via, fino a quando non viene raggiunto il router r t direttamente connesso a v, che trasmette il pacchetto al destinatario. Il percorso seguito da un pacchetto è quindi determinato dalle tabelle di routing dei router nella rete, e in particolare dai router attraversati dal pacchetto stesso. Per rendere più efficiente la trasmissione del messaggio, e in generale, l'utilizzo complessivo della rete, tali tabelle devono instradare il messaggio lungo il percorso più efficiente (o, in altri termini, meno costoso) che collega u a v. Le caratteristiche di un collegamento diretto tra due router (come la velocità di trasmissione), così come la quantità di traffico (ad esempio, pacchetti per secondo) che viaggia su di esso, consentono, a ogni istante, di assegnare un costo alla trasmissione di un pacchetto sul collegamento. Un'assegnazione di costi a tutti i collegamenti tra router consente di modellare l'infrastruttura dei router come un grafo orientato pesato sugli archi, i cui nodi rappresentano i router, gli archi i collegamenti diretti tra router e il peso associato a un arco il 2

A1 fine di rendere più agevole la comprensione degli aspetti rilevanti per le finalità di questo libro, stiamo volutamente semplificando l'esposizione dei meccanismi di routing su Internet.

costo di trasmissione di un pacchetto sul relativo collegamento. In tal modo, l'obiettivo di effettuare il routing di un pacchetto nel modo più efficiente si riduce nel cercare, dato il grafo pesato che modella la rete, il cammino di costo minimo dal router associato a u a quello associato a v. I router utilizzano dei protocolli appositi per raccogliere le informazioni sui costi di tutti i collegamenti, e per costruire quindi le tabelle di routing che instradano i messaggi lungo i percosi più efficienti. Tali protocolli rientrano in due tipologie: link state e distance vector. I protocolli link state, come ad esempio OSPF (Open Shortest Path First), operano in modo tale che tutti i router, scambiandosi opportuni messaggi, acquisiscono l'intero stato della rete, e quindi tutto il grafo pesato che modella la rete stessa. A questo punto ogni router Ti applica su tale grafo un algoritmo di ricerca, come l'algoritmo di Dijkstra che esamineremo di seguito, per determinare l'insieme dei cammini minimi da r a qualunque altro router: se ti, t j , . . . , r s è il cammino minimo individuato da r^ che passa attraverso il router Tj a lui vicino, la tabella di routing di r^ associa il router Tj a tutti gli indirizzi verso r s . I protocolli distance vector, come ad esempio RIP (Routing Information Protocol) effettuano la determinazione dei cammini minimi senza scambiare l'intero grafo tra i router. Essi invece applicano un diverso algoritmo per la ricerca dei cammini minimi da un nodo a tutti gli altri, l'algoritmo di Bellman-Ford, che esamineremo anch'esso nel seguito: tale algoritmo, come vedremo, ha la peculiarità di operare mediante aggiornamenti continui operati in corrispondenza agli archi del grafo e, per tale caratteristica, si presta a un'elaborazione "collettiva" dei cammini minimi da parte di tutti i router nella rete.

8.3.1

Problema della ricerca di cammini minimi su grafi

La ricerca del cammino più corto {shortest path) tra due nodi in un grafo rappresenta un'operazione fondamentale su questo tipo di struttura, con importanti applicazioni. In generale, come osservato sopra, la conoscenza dei cammini minimi tra i nodi è un importante elemento in tutti i metodi di routing su rete, vale a dire in tutti i metodi che, dati una origine e una destinazione di un messaggio, determinano il percorso più conveniente da seguire per il messaggio stesso. Tra questi, particolare importanza riveste l'instradamento di pacchetti su Internet, come visto sopra, ma anche altre applicazioni di larga diffusione, quali ad esempio la ricerca del miglior percorso stradale verso una destinazione effettuata da un navigatore satellitare o da sistemi disponibili su Internet e largamente utilizzati quali MapQuest, GoogleMaps, YahooMaps o MSNMaps operano sulla base di algoritmi per la ricerca di cammini minimi. Come già visto nel Paragrafo 7.4, in un grafo non pesato il cammino minimo tra due nodi u e v può essere trovato mediante una visita in ampiezza a partire da u, utilizzando

20

Figura 8.4

Esempio di grafo orientato con pesi sugli archi.

una coda in cui memorizzare i nodi man mano che vengono raggiunti e da cui estrarli, secondo una politica FIFO, per procedere nella visita. Consideriamo ora il caso generale in cui il grafo G = (V, E) sia pesato con valori reali sugli archi attraverso una funzione W : E >—» IR: come già notato nel Paragrafo 6.1, un cammino v 0 , v i , v 2 , . . . .v^ ha associato un peso (che interpretiamo come lunghezza) pari alla somma W ( V Q , V ] ) + W ( V I , V 2 ) + ... + W F V K - i . V I J dei pesi degli archi che lo compongono. Nel seguito, la lunghezza sarà intesa come peso totale del cammino. Dati due nodi u, v e V, esistono in generale più cammini che collegano u a v, ognuno con una propria lunghezza: ricordiamo che la distanza pesata 6(u, v) da u a v è definita come la lunghezza del cammino di peso minore da u a v. Notiamo che, se il grafo è non orientato, vale 6(u, v) = 6(v, u), in quanto a ogni cammino da u a v corrisponde un cammino (il medesimo percorso al contrario) da v a u della stessa lunghezza: ciò non è vero, in generale, se il grafo è orientato. Per il grafo nella Figura 8.4, possiamo osservare ad esempio che 6(vi, v R, richiede di individuare i cammini di lunghezza minima tra i nodi del grafo stesso. Tale problema assume caratteristiche diverse, in termini di miglior modo di risolverlo, in dipendenza del numero di cammini minimi che ci interessa individuare nel grafo: in particolare, se siamo interessati a individuare gli n ( n — 1 ) cammini minimi tra tutte le coppie di nodi (alipairs shortestpath),

avremo che i metodi più efficienti di soluzione possono essere diversi rispetto al caso in cui ci interessano soltanto gli n — 1 cammini minimi da un nodo a tutti gli altri (single source shortest path). Come vedremo, la complessità di risoluzione di questo problema dipende, tra l'altro, dalle caratteristiche della funzione W: in particolare, considereremo dapprima il caso in cui W : E i—» R + , in cui cioè i pesi degli archi sono positivi. Sotto questa ipotesi introdurremo il classico algoritmo di Dijkstra (definito per il caso single source, ma utilizzabile anche per quello alipairs), e vedremo che questo algoritmo è una riproposizione degli algoritmi di visita discussi nel Paragrafo 7.4, in cui viene utilizzata però una coda con priorità come struttura di dati, al posto della coda e della pila. Nel caso generale in cui i pesi degli archi possono essere anche nulli o negativi, non possiamo usare l'algoritmo di Dijkstra. Vedremo allora come risolvere il problema diversamente, per quanto riguarda sia la ricerca ali pairs che quella single source, anche se meno efficientemente del caso in cui i pesi sono positivi.

8.3.2

Cammini minimi in grafi con pesi positivi

Consideriamo inizialmente il problema di tipo single source-. in tal caso, dato un grafo G = (V, E, W) con W : E >—> R + e dato un nodo s € V, vogliamo derivare la distanza ó(s,v) da s a v, per ogni nodo v € V. Se ad esempio consideriamo ancora il grafo nella Figura 8.4, allora per s = v j vogliamo ottenere l'insieme di coppie (vj, 0), (v2, 57), ( v 3 , l l ) , ( V 4 , 9 ) , (V 5 ,20), (V 6 ,35), (V 7 ,18), (v 8 ,14), (v 9 ,+oo), (v, 0 ,+oo), ( v n , + o o ) , (vi2, +oo), associando a ogni nodo la relativa distanza da v j . Inoltre, vogliamo ottenere anche, per ogni nodo, il cammino minimo stesso: a tal fine, ci è sufficiente ottenere, per ogni nodo v, l'indicazione del nodo u che precede v nel cammino minimo da s a v stesso. Ciò e sufficiente in quanto vale la proprietà che se il cammino minimo da s a v è da- , to dalla sequenza di nodi s, uo, U i , . . . , u T , u , v, allora la sequenza s, u < ) , u j , . . . , u ^ , u è il cammino minimo da s a u: se infatti così non fosse ed esistesse un altro cammino s , w o , w i , . . . , w t , u più corto, allora anche il cammino s , w o , w i W t , u , v avrebbe lunghezza inferiore a s , u o , u . i , . . . , u r , u , v, contraddicendo l'ipotesi fatta che tale cammino sia minimo. Come vedremo ora, questo problema può essere risolto mediante un algoritmo di visita del grafo che fa uso di una coda con priorità per determinare l'ordine di visita dei nodi e che viene indicato come algoritmo di Dijkstra. Gli elementi nella coda con priorità sono coppie (v, p), con v € V e p £ IR + , ordinate rispetto ai rispettivi pesi p: come vedremo, l'algoritmo mantiene l'invariante che, per ogni coppia (v, p) nella coda con priorità, abbiamo p ^ ó(s,v) e, nel momento in cui (v,p) viene estratta dalla coda con priorità, abbiamo p = 6(s,v).

Dijkstra( s ): FOR (u = 0; u < n; u = u + 1) { pred[u] = -1; dist[u] = +oo;

> pred[s] = s; dist [s] = 0; FOR (u = 0; u < n; u = u + 1) { elemento.peso = dist[u]; elemento.dato = u; PQ.Enqueue( elemento );

} WHILE (!PQ.Empty( )) {

e = PQ.Dequeue( ); v = e.dato; FOR (x = listaAdiacenza[v].inizio; x != nuli; x = x.succ) -t u = x.dato; IF (dist[u] > dist[v] + x.peso) { dist[u] = dist[v] + x.peso; pred[u] = v; PQ.DecreaseKeyC u, dist[u] );

> > > Codice 8.7

Algoritmo di Dijkstra per la ricerca dei cammini minimi single source, dove la variabile elemento indica un nuovo elemento allocato.

In particolare, a ogni istante il peso p associato al nodo v nella coda con priorità indica la lunghezza del cammino più corto trovato finora nel grafo: tale peso viene aggiornato ogni qual volta viene individuato un cammino più breve da s a v di quello considerato finora. L'algoritmo, mostrato nel Codice 8.7, determina la distanza di ogni nodo in V da s, oltre al corrispondente cammino minimo, utilizzando due array: d i s t associa a ogni nodo v la lunghezza del più breve cammino da s a v individuato finora e p r e d rappresenta il nodo che precede v in tale cammino. Per effetto dell'esecuzione del ciclo iniziale (righe 2—12), per ogni nodo v e V - {s}, d i s t [ v ] viene posto pari a +00 in quanto al momento non conosciamo alcun cammino da s a v; inoltre viene posto d i s t [ s ] pari a 0 in quanto s dista 0 da se stesso. I valori pred[v] vengono posti, per tutti i nodi eccetto s, pari a —1, valore utilizzato per codificare il fatto che non è noto alcun cammino da s a v, mentre per s adottiamo

la convenzione che pred[s] = s. Tutti i nodi vengono inoltre inseriti nella coda con priorità, con associati i rispettivi pesi. Nel ciclo successivo (righe 13—24), l'algoritmo procede a estrarre dalla coda con priorità il nodo v con peso minimo (riga 14): come vedremo sotto, il peso associato al nodo è pari alla distanza ó(s,v). In corrispondenza a questa estrazione, vengono esaminati tutti gli archi uscenti da v (righe 16-23): per ogni arco x = (v, u) considerato, ci chiediamo se il cammino s , . . . , v , u , di lunghezza 6(s,v) + W ( v , u ) = d i s t [ v ] + x . p e s o , è più corto della distanza del cammino minimo da s a u trovato fino a ora, dove tale distanza è memorizzata in d i s t [ u ] . In tal caso (o nel caso in cui s , . . . , v , u sia il primo cammino trovato da s a u) il peso associato a u viene decrementato al valore 6(s, v) + W(v, u) (riga 21) e v diventa il predecessore di u nel cammino minimo. ALVIE:

algoritmo di Djikstra Osserva, sperimenta e verifica

Dijkstra

Il decremento del peso di un elemento in una coda con priorità viene eseguito mediante l'operazione DecreaseKey descritta nel Paragrafo 8.2.2. Possiamo notare che il peso associato a un nodo v e V — {s} non è mai inferiore alla distanza 6(s, v), in quanto all'inizio tale peso è pari a +00 e ogni volta che viene aggiornato viene posto pari alla lunghezza di un qualche cammino esistente da s a v, di lunghezza quindi non inferiore a ó(s,v). Per quanto riguarda s, il suo peso è posto pari alla distanza da se stesso e mai aggiornato, in quanto s è necessariamente il primo nodo estratto dalla coda con priorità. Inoltre, per la struttura dell'algoritmo, la sequenza dei pesi associati nel tempo a ogni nodo v è monotona decrescente. Ciò che è necessario mostrare, per convincerci che l'algoritmo restituisce le distanze da s a tutti i nodi, è che il peso d i s t [ v ] di un nodo v al momento della sua estrazione dalla coda con priorità è pari a 6(s, v). A tal fine, dato un intero i > 0 e un nodo v e V, indichiamo con Si l'insieme dei primi i nodi estratti dalla coda e con 6t(s, v) la lunghezza del cammino minimo da s a v passante per soli nodi in Si. Mostriamo ora che, dopo che l'algoritmo ha considerato i primi i nodi estratti, se un nodo v è ancora nella coda il peso a esso associato è pari alla lunghezza del cammino minimo da s a v passante per i soli nodi in Si, e quindi che d i s t [ v ] = 6i(s, v). Questo è vero all'inizio dell'algoritmo quando, dopo la prima iterazione nella corso della quale è stato estratto s, per ogni nodo v adiacente a s abbiamo d i s t [ v ] = W(s, v).

Figura 8.5

Dimostrazione di correttezza dell'algoritmo di Dijkstra.

Dato che W(s,v) è anche la lunghezza dell'unico cammino che collega s a v passando per soli nodi in Si = {s}, e quindi abbiamo in effetti d i s t [ v ] = ói(s,v). Ragionando per induzione, facciamo ora l'ipotesi che la proprietà sia vera dopo k— 1 nodi estratti dalla coda con priorità, e mostriamo che rimane vera anche dopo k estrazioni. Supponiamo che u sia il k-esimo nodo estratto: per l'ipotesi induttiva, il peso di u nella coda al momento dell'estrazione è pari alla lunghezza del più corto cammino da s a u passante per i soli nodi in S ^ - i , e quindi d i s t [ u ] = ók_i (s,u). Consideriamo ora un qualunque nodo v adiacente a u e non ancora estratto, e consideriamo il cammino minimo da s a v passante per i soli nodi in Sk = Sk_i U {u}. Possiamo avere due possibilità: 1. tale cammino non passa per u, nel qual caso corrisponde al cammino minimo passante soltanto per nodi in S ^ - i , e quindi ó i j s . v ) = ó^-i (s,v); 2. tale cammino passa anche per u, nel qual caso corrisponde al cammino minimo da s a u seguito dall'arco (u, v), e ó^fs, v) = ó ^ - i (s,u) + W(u, v). In entrambi i casi possiamo verificare come l'algoritmo del Codice 8.7 operi in modo da assegnare a d i s t [ v ] il valore &k(s,v), e quindi da mantenere vera la proprietà che stiamo mostrando. Mostriamo ora che, se v g V è l'i-esimo nodo estratto, il cammino minimo da s a v passa necessariamente per i soli nodi in Si. Infatti, supponiamo per assurdo che tale cammino passi per alcuni nodi che si trovano ancora nella coda al momento in cui v viene estratto, e indichiamo con w il primo di tali nodi che compare nel cammino minimo (Figura 8.5).

Dato che w precede v in tale cammino minimo, avremmo che 6(s,w) < ó(s,v); inoltre, dato che stiamo ipotizzando che il cammino minimo non passi tutto per nodi in Si, abbiamo che ó(s,v) < ói(s,v); infine, dato che v viene estratto dalla coda con priorità prima di w, abbiamo che 6i(s,v) < 6t(s,w). Ma ciò porta a una contraddizione, se consideriamo che, dato che w è per ipotesi il primo nodo non appartenente a St nel cammino minimo, abbiamo anche 6(s,w) = ói(s,w): infatti, otteniamo allora che 6(s, w) < 6(s,v) < ói(s,v) < ói(s,w) = 6(s,w), il che è impossibile. Qual è il costo computazionale dell'algoritmo del Codice 8.7? Dato che l'algoritmo si limita a gestire in modo opportuno una coda con priorità, il suo costo dipenderà dal costo delle operazioni eseguite su tale struttura. Indichiamo allora con t c il costo di costruzione della coda, con t e il costo di estrazione del minimo con l'operazione Dequeue e con td il costo dell'operazione D e c r e a s e K e y . Come possiamo osservare, su un grafo di n nodi e m archi, l'algoritmo esegue n estrazioni del minimo e al più m D e c r e a s e K e y , da cui consegue che il suo tempo di esecuzione è 0 ( t c + n t e + m t d ) . Se utilizziamo l'implementazione della coda con priorità mediante uno heap, descritta nel Paragrafo 8.2, abbiamo che t c = O(n), t e = O(logn) e td = O(logn), per cui l'algoritmo ha costo complessivo pari a 0 ( ( n + m) logn) tempo, che risulta O ( m l o g n ) se supponiamo che il grafo sia connesso, e quindi m = n ( n ) . Possiamo ottenere un miglioramento del costo dell'algoritmo utilizzando la semplice implementazione a lista della coda con priorità: infatti, se tale implementazione viene effettuata per mezzo di una lista non ordinata, avremo che t c = O(n), t e = O(n) e td = 0(1), in quanto il decremento del peso di un nodo non comporta alcuna riorganizzazione della struttura. In questo caso, il costo dell'algoritmo risulta 0 ( n 2 + m), che è migliore del caso precedente per grafi densi, in cui in particolare il numero di archi è m = Q(n2/logn). In generale, possiamo pensare di ridurre il costo complessivo dell'algoritmo, almeno su grafi non sparsi, diminuendo il costo dell'operazione D e c r e a s e K e y a fronte di un aumento del costo dell'operazione Dequeue. Un modo, più bilanciato, di ottenere ciò è quello di utilizzare heap non binari, ma di grado d > 2: in questo caso, la profondità dello heap, e quindi il costo della f D e c r e a s e K e y diviene log d n , mentre la Dequeue richiede tempo 0 ( d l o g d n) in quanto deve esaminare, a ogni livello, tutti i d figli del nodo attuale. Da ciò deriva che il tempo di esecuzione dell'algoritmo diviene 0 ( n d l o g d n + m l o g d n), che è minimo, al variare di d, quando n d = m, e quindi quando d = m / n . Per tale valore di d ottieniamo allora un costo dell'algoritmo pari a O ( m l o g m / n n), che risulta 0 ( m ) se m = B(n 2 ) e O ( n l o g n ) se m = 0 ( n ) . Osserviamo infine che esiste un'implementazione della coda con priorità, lo heap di Fibonacci, che consente di effettuare le operazioni Enqueue, Dequeue e D e c r e a s e K e y con un costo ammortizzato rispettivamente pari a 0 ( 1 ) , O(logn) e 0(1). Ciò, in con-

seguenza anche di quanto visto nel Paragrafo 3.4.1, comporta che ogni sequenza di p operazioni Enqueue, di q ^ p operazioni Dequeue e di r operazioni DecreaseKey ha un costo complessivo di 0 ( p -I- r + q logn) tempo. L'utilizzo di questa implementazione permette allora di eseguire l'algoritmo del Codice 8.7 in tempo 0 ( n l o g n + m), che rappresenta il miglior costo possibile nel caso di grafi con m = O ( n l o g n ) . La ricerca dei cammini minimi tra tutte le coppie di nodi (vale a dire nel caso ali pairs) può essere effettuata applicando n volte, una per ogni possibile nodo sorgente, l'algoritmo di Dijkstra illustrato sopra: ciò fornisce un metodo di soluzione di tale problema avente costo O ( n l o g n + n m ) .

8.3.3

Cammini minimi in grafi pesati generali

L'algoritmo di Dijkstra non è applicabile al problema dei cammini minimi quando gli archi del grafo possono avere pesi negativi o nulli, perché un arco potrebbe diminuire la lunghezza del cammino di un nodo già estratto dalla coda con priorità. Per trattare la versione generale del problema dobbiamo comunque ipotizzare che nel grafo, anche in presenza di archi a peso negativo, non esistano cicli aventi peso complessivo negativo (vale a dire che è negativa la somma dei pesi degli archi corrispondenti): se v ^ , v i 2 , . . . , v¿ k , v i ( fosse un tale ciclo, avente peso —D, la distanza tra due qualunque di tali nodi sarebbe —oo. Notiamo infatti che attraversare il ciclo comporta che la distanza complessivamente percorsa viene decrementata di D, e quindi, dato che esso può essere percorso un numero arbitrariamente grande di volte, la distanza può divenire arbitrariamente grande in valore assoluto e negativa. Notiamo inoltre che ciò avviene non solo per quanto riguarda la distanza tra due nodi del ciclo, ma in realtà per tutte le coppie di nodi nella stessa componente connessa che include il ciclo stesso e quindi, se il grafo è connesso per tutte le coppie di nodi, la cui distanza risulta quindi pari a —oo. Il metodo più diffuso per la ricerca single source dei cammini minimi è il cosiddetto algoritmo di Bellman-Ford, che opera come mostrato nel Codice 8.8. L'algoritmo ha una struttura molto semplice e simile a quello di Dijkstra. Come possiamo vedere, non necessita di strutture di dati particolari: anche in questo caso per ogni nodo v viene mantenuta in d i s t [ v ] la lunghezza del cammino più breve da s a v finora trovato dall'algoritmo e in pred[v] il nodo che precede immediatamente v lungo tale cammino. Facciamo l'ipotesi che il valore - 1 per pred[v] stia a rappresentare il fatto che non viene

rappresentato alcun cammino da s a v; inoltre, poniamo anche predts] = s. Dopo l'inizializzazione (righe 2 - 7 ) come nell'algoritmo di Dijkstra, l'algoritmo opera per n = |V| iterazioni la scansione di tutti gli archi di G (righe 8-17): per ogni arco (u,v) esaminato, verifichiamo se i valori d i s t [ u ] e d i s t [ v ] soddisfano la condizione d i s t [ u ] > d i s t [ v ] 4- W ( u , v) (riga 12). Se è così, questo vuol dire che esiste un cam-

Bellman-FordC FOR (u = 0; pred[u] = dist[u] =

s ) : u < N; u = u + 1) { -1; +00;

> pred[s] = s; dist [s] = 0; FOR (i = 0; i < N; i = i + 1) FOR (v = 0; v < N; v = v + 1) { FOR (X = listaAdiacenza[v].inizio; x != nuli; x=x.succ) { u = x.dato; IF (dist[u] > dist[v] + x.peso) { dist[u] = dist[v] + x.peso; pred[u] = v;

> > > Codice 8.8

Algoritmo di Bellman-Ford per la ricerca dei cammini minimi single source.

mino s , . . . , v , u più breve del miglior cammino da s a u trovato finora: le informazioni d i s t [ u ] e d i s t [ v ] vengono allora aggiornate per rappresentare questa nuova situazione. ALVIE:

algoritmo di Bellman-Ford C5> • Osserva, sperimenta e verifica BellmanFord

-JOD CH

: vi».

Per mostrare che l'algoritmo opera correttamente anche con pesi negativi e nulli e quindi, al momento della sua terminazione, abbiamo d i s t [ v ] = 6(s, v) per ogni nodo v, ragioniamo per induzione: verifichiamo che, all'inizio dell'iterazione i nel ciclo più esterno (righe 8—17), abbiamo che d i s t [ v ] = ó(s, v) per ogni nodo v per il quale il cammino minimo da s a v è composto da al più i archi. Questa proprietà è vera per i = 0, in quanto s è il solo nodo tale che il cammino minimo da s a s è composto da 0 archi, e in effetti d i s t [ s ] = 0 = ó(s, s). Per il passo induttivo, ipotizziamo ora che la proprietà sia vera all'inizio dell'iterazione i: se consideriamo un qualunque nodo v tale che il cammino minimo s , . . . , u , v comprende i + 1 archi, ne consegue che per il nodo u il cammino minimo s , . . . , u com-

prende i primi i archi del cammino precedente, e quindi abbiamo d i s t [ u ] = ó(s,u). Ma allora, nel corso dell'iterazione i, abbiamo che d i s t [ v ] è aggiornato in modo che d i s t [ v ] = d i s t [ u ] -I-W(u,v) = ó(s,v) + W(u,v), che è uguale a 6(s,v) per l'ipotesi che il cammino s , . . . , u , v sia minimo. Quindi la proprietà risulta soddisfatta quando inizia l'iterazione i + 1. Se osserviamo che, dato che non esistono per ipotesi cicli di lunghezza negativa in G, un cammino minimo comprende al più n — 1 archi, possiamo concludere che quando i = n tutti i cammini minimi sono stati individuati. Per quanto riguarda il costo di esecuzione, possiamo notare che l'algoritmo esegue O(n) iterazioni, in ognuna delle quali esamina ogni arco due volte, e quindi esegue O(m) operazioni: ne consegue che il tempo di esecuzione è O(nm). Abbiamo quindi che la più vasta applicabilità (anche a grafi con pesi negativi, se non abbiamo cicli negativi) rispetto all'algoritmo di Dijkstra viene pagata da una minore efficienza. Osserviamo infine che, per quanto detto, se l'algoritmo effettuasse più di n iterazioni, l'ultima di esse non vedrebbe alcun aggiornamento dei valori nell'array d i s t , in quanto i cammini minimi sono stati già tutti trovati. Invece, se il grafo avesse cicli di lunghezza negativa, ci sarebbero valori in d i s t [ v ] che continuerebbero a decrementarsi indefinitamente. Da questa osservazione deriva che l'algoritmo di Bellman-Ford può essere utilizzato anche per verificare se un grafo G presenta cicli di lunghezza negativa. A tal fine, se n è il numero di nodi, basta eseguire n + 1 iterazioni e verificare se nel corso dell'ultima vengono modificati valori nell'array d i s t : se così è, possiamo concludere che il grafo presenta in effetti dei cicli negativi. Se consideriamo ora il problema della ricerca dei cammini minimi tra tutti i nodi, possiamo dire che una semplice soluzione è data, come nel caso dei grafi a pesi positivi, dall'iterazione su tutti i nodi dell'algoritmo per la ricerca single source: nel nostro caso, questo risulterebbe in un tempo di esecuzione 0 ( n 2 m ) . Possiamo tuttavia ottenere di meglio utilizzando il paradigma della programmazione dinamica, introdotto nel Paragrafo 2.7. Per seguire questo approccio, utilizziamo la rappresentazione dei grafi pesati mediante la matrice di adiacenza A a cui è associata quella dei pesi P, tale che P[u, v] = W(u, v) se e solo se A[u,v] = 1 (vale a dire (u,v) £ E), dove richiediamo che P[u, u] = 0 per 0 ^ u, v < n: gli altri valori di P sono considerati pari a +00 in quanto non esiste un arco di collegamento. Dato un cammino da u a v, definiamo come nodo interno del cammino un nodo w, diverso sia da u che da v, che compare nel cammino stesso. Per ogni k < n, indichiamo con V^ l'insieme dei primi k nodi di V, abbiamo cioè per definizione che Vk={0,l,...,k-1}. Possiamo allora considerare, per ogni coppia di nodi u e v e per ogni k, il cammino minimo ^ ( u , v) da u a v passante soltanto per nodi in V^ (eccetto per quanto riguarda

u e v stessi): se k = n tale cammino è il cammino minimo 7t(u,v) da u a v nell'intero grafo. Inoltre, dato che Vo = 0, il cammino minimo 7to(u,v) da u a v in Vo è dato dall'arco (u, v), se tale arco esiste. Se indichiamo con 6|c(u, v) la lunghezza del cammino 7t k (u,v), avremo allora che 6o(u,v) = W ( u , v ) se (u,v) G E, mentre óo(u,v) = +00 altrimenti. Se soffermiamo la nostra attenzione sul cammino minimo Tt^fu.v) per 0 < k ^ n , possiamo notare che possono verificarsi due eventualità: 1. il nodo k— 1 non appare in ^ ( u , v), ma allora ^ ( u , v) = 7tic_ 1 (u, v) (il cammino minimo è lo stesso che nel caso in cui utilizzavamo soltanto i nodi {0,1 k — 2} come nodi interni); 2. al contrario, il nodo k—1 appare in ^ ( u , v), ma allora, dato che tale cammino non può contenere cicli in quanto ogni ciclo (che non può avere lunghezza negativa) lo renderebbe più lungo, 7tk(u, v) può essere suddiviso in due parti: un primo cammino da u a k — 1 passante soltanto per nodi in Vk_i e un secondo cammino da k — 1 a v passante anch'esso per soli nodi in V k _ 1. Possiamo quindi derivare la seguente regola di programmazione dinamica per calcolare la lunghezza ó^fu, v) del cammino minimo da u a v: Si

{

ì= i

k|U VJ

'

S

p u,v

t l m i n { 6 k _ I ( u , v ) , 6 l c _ 1 ( u , k - 1) + S k _ , (k - l,v)}

se k = 0 se k > 1

Seguendo l'approccio della programmazione dinamica, abbiamo quindi un meccanismo di decomposizione del problema in sottoproblemi più semplici, con una soluzione definita per i sottoproblemi elementari, corrispondenti al caso k = 0. A questo punto, l'algoritmo risultante, detto algoritmo di Floyd-Warshall, presenta l'usuale struttura di un algoritmo di programmazione dinamica. In particolare, esso opera (almeno concettualmente) su una coppia di tabelle tridimensionali d i s t e p r e d , ciascuna di n "strati", n righe e n colonne: per il cammino 7t k (u, v), l'algoritmo utilizza queste tabelle per memorizzare 6k(u, v) in d i s t [ k , u, v] secondo la relazione (8.2) e il predecessore di v in tale cammino in p r e d [ k , u , v]. In realtà, un più attento esame dell'equazione (8.2) mostra che possiamo ignorare l'indice k — 1: infatti 6 k - i (u, k — 1) = 6k(u, k — 1) e ó ^ i i k — 1, v) = ók(k — 1, v) in quanto il nodo di arrivo (nel primo caso) e di partenza (nel secondo caso) è k — 1, il quale non può essere un nodo interno in tali cammini quando passiamo da V k _i a Vy. Tale osservazione ci permette di utilizzare le tabelle bidimensionali n x n per rappresentare d i s t e p r e d , come possiamo vedere nel Codice 8.9. L'algoritmo, dopo una prima fase di inizializzazione degli elementi d i s t [ u , v] (righe 2-5), passa a derivare iterativamente tutti i cammini minimi in al crescere di k

Floyd-Warshall( FOR (u = 0; u FOR (v = 0; dist[u,v]

): < n; u = u + 1) v < n; v = v + 1) { = P[u,v];

> FOR (k = 1; k <= n; k = k + 1)

FOR ( u = 0 ; u < n ; u = u + 1) { FOR ( v = 0 ; v < n ; v = v + l ) { IF (dist[u,v] > dist[u,k-l] + dist[k-l,v]) { dist[u,v] = dist[u,k-l] + dist[k-l,v]; pred[u,v] = pred[k-l,v];

>

>

> Codice 8.9 Algoritmo di Floyd-Warshall per la ricerca dei cammini minimi alipairs.

(righe 6—14). A tal fine, utilizza la relazione di programmazione dinamica riportata in (8.2) per inferire, alla riga 9, quale sia il cammino minimo 7tk(u,v) e quindi quali valori memorizzare per rappresentare tale cammino e la relativa lunghezza (righe 10—12). Il costo dell'algoritmo è determinato dai tre cicli nidificati, da cui deriva un tempo di computazione 0 ( n 3 ) ; per quanto riguarda lo spazio utilizzato, il Codice 8.9 fa uso, come detto sopra, di due array di n x n elementi, totalizzando 0 ( n 2 ) spazio. ALVIE:

algoritmo di Floyd-Warshall

Osserva, sperimenta e verifica FloydWarshall

8.4

Opus libri: data mining e minimi alberi ricoprenti

In applicazioni di data mining è necessario operare su insiemi di dati di grandi dimensioni, ad esempio di carattere sperimentale, per individuare delle regolarità nei dati trattati o similitudini tra loro sottoinsiemi: il tutto nel tentativo di derivare un'ipotesi di legge, un qualche tipo di conoscenza induttivo della realtà soggiacente ai dati. Tipici casi di tali applicazioni sono ad esempio l'analisi di una rete sociale con l'obiettivo di individuare

le comunità al suo interno, o il partizionamento di una collezione di documenti su un insieme di tematiche. In questo contesto, un metodo applicato in modo estensivo è l'analisi di cluster (cluster analysis), vale a dire il partizionamento di dati osservati in sottoinsiemi, detti cluster, in modo tale che i dati in ciascun cluster condividano qualche proprietà comune, non posseduta da dati esterni al cluster. In genere, l'individuazione dei cluster viene effettuata in termini di prossimità dei dati rispetto a una qualche metrica definita su di essi che ne misura la distanza: a tal fine, i dati possono essere proiettati, eventualmente per mezzo di una qualche funzione predefinita, su uno spazio k-dimensionale, utilizzando la normale distanza euclidea come metrica di riferimento. Sono stati definiti numerosi metodi per l'individuazione di una partizione in cluster: la scelta del più efficace da utilizzare rispetto a un determinato insieme di dati è spesso molto ardua. La maggior parte dei metodi richiede inoltre l'assegnazione di valori a una serie di parametri, o addirittura la predeterminazione del numero di cluster da ottenere. In tale contesto, una tecnica piuttosto semplice, diffusa ed efficace in molte situazioni, derivata dalla teoria dei grafi, è basata sull'uso di alberi minimi di ricoprimento. Il problema del minimo albero di ricoprimento o minimo albero ricoprente (minimum spanning tree) è uno dei problemi su grafi più semplici da definire e più studiati. Ricordiamo che, dato un grafo non orientato e connesso G = (V, E), un albero di ricoprimento di G è un albero T i cui archi sono anche archi del grafo e collegano tutti i nodi in V (Paragrafo 7.4), ossia un albero T = (V, E'), dove E' C E. Un tale albero è minimo se la somma dei pesi nei suoi archi è la minima tra quelle di tutti i possibili alberi di ricoprimento (notiamo come nel caso in cui G non sia connesso non esiste alcun albero che lo ricopre: possiamo però definire una foresta di ricoprimento di G, vale a dire un insieme di alberi, ciascuno ricoprente la propria componente connessa). Nel seguito faremo sempre l'ipotesi che G sia connesso. Nel data mining basato sull'analisi dei cluster, i dati sono rappresentati da punti in uno spazio k-dimensionale. Un esempio è nell'analisi del genoma, in cui è possibile monitorare simultaneamente k parametri numerici per decine di migliaia di geni (che reagiscono a cambiamenti imposti al loro ambiente) attraverso dei dispositivi speciali chiamati microarray, i quali forniscono un insieme di punti k-dimensionali in uscita. In tal caso, il clustering basato sull'albero minimo di ricoprimento opera a partire dal grafo G = (V, E, W) in cui V è l'insieme dei punti, E è l'insieme di tutte le possibili coppie di punti (quindi G è un grafo completo di tutti gli archi) e W è la distanza euclidea tra i punti: in tale contesto l'albero minimo di ricoprimento viene detto euclideo. L'albero risultante può essere utilizzato come base per il partizionamento in cluster: come vedremo, infatti, ogni arco e dell'albero è l'arco di peso inferiore tra quelli in grado j3® di collegare le due porzioni di albero ottenute dall'eventuale rimozione di e.

In termini di data mining, la rimozione di e dà luogo a una separazione tra due cluster in cui la distanza tra due qualsiasi punti, uno per cluster, non può essere inferiore al peso di e. Scegliendo di rimuovere gli archi più lunghi (di peso maggiore) presenti nell'albero minimo di ricoprimento, abbiamo che iniziamo a separare i cluster più distanti tra di loro: osserviamo infatti che punti appartenenti alla stessa porzione di albero formano un cluster e che cluster diversi tendono a essere collegati da archi più lunghi. La rimozione di ogni successivo arco lungo, separa ulteriormente i cluster. In generale, dopo k rimozioni di archi dall'albero, otteniamo k + 1 cluster, tendendo così a separare insiemi di nodi "lontani" tra loro, al fine di ottenere cluster il più possibile significativi. Comunque, non è detto che la sola eliminazione degli archi più lunghi nell'albero fornisca una partizione in cluster accettabile: ad esempio, alcuni cluster ottenuti possono essere eccessivamente piccoli per le finalità dell'analisi dei dati effettuata. Spesso, può essere necessario aggiungere ulteriori criteri di scelta degli archi da eliminare, in modo da migliorare la significatività della partizione ottenuta.

8.4.1

Problema della ricerca del minimo albero di ricoprimento

Come già visto nel Paragrafo 7.4, un qualunque albero di ricoprimento di un grafo può essere trovato in tempo 0 ( n + m) mediante una visita (sia in ampiezza che in profondità) del grafo stesso: gli alberi BFS e DFS risultanti da tali visite non sono altro che particolari alberi di ricoprimento. Consideriamo ora, come nel paragrafo precedente, il caso in cui l'insieme degli archi sia pesato per mezzo di una funzione W : E — R + e che il grafo sia connesso e non orientato e connesso. In questa ipotesi ogni albero ricoprente T = (V, E') di G ha associato un peso Y - e e f W(e) pari cioè alla somma dei pesi dei suoi archi. Quel che vogliamo è allora trovare, fra tutti gli alberi ricoprenti di G, quello avente peso minimo (laddove gli alberi BFS e DFS non sono necessariamente di peso minimo). Introduciamo ora due proprietà strutturali del minimo albero ricoprente, che saranno utilizzate negli algoritmi che considereremo per questo problema: queste proprietà fanno riferimento al concetto di ciclo, già introdotto nel Paragrafo 6.1, e alla nuova nozione di taglio in un grafo connesso. Dato un grafo G = (V, E), un taglio {cut) su G è un qualunque sottoinsieme C C E di archi la cui rimozione disconnette il grafo, nel senso che il grafo G' = (V, E — C) è tale che esistono almeno due nodi u , v € V tra i quali non esiste un cammino. Ad esempio, nella Figura 8.6 viene mostrato un taglio (riportato graficamente come una linea più spessa) che corrisponde all'insieme di archi C = {(v^vs), (vi,vs), (v4,vy), v v ( v 4 » v 2 ) . ( v 3 > v 7 ) > ( v 3 > v 2 ) > ( i > 5 ) l - Come possiamo verificare, la rimozione degli archi nel taglio disconnette il grafo in due componenti disgiunte {vi, V3, V4} e (V2, V5, vg, V7, vg}. Enunciamo ora le due proprietà di un minimo albero ricoprente che utilizzeremo per mostrare la correttezza degli algoritmi che considereremo nel seguito. Dato un grafo

Figura 8.6

Esempio di taglio in un grafo.

G = (V, E) pesato sugli archi e un suo minimo albero ricoprente T = (V, E'), per ogni arco e G E abbiamo che: Condizione di taglio e £ E' se e solo se esiste un taglio in G che comprende e, per il quale e è l'arco di peso minimo; Condizione di ciclo e 0 E' se e solo se esiste un ciclo in G che comprende e, per il quale e è l'arco di peso massimo. Per convincerci della prima proprietà, osserviamo che se e e E' allora la sua rimozione disconnette i nodi su T in due componenti V', V" (ricordiamo che la rimozione di un qualunque arco di un albero disconnette l'albero stesso). L'insieme che comprende sia e che tutti gli archi (v',v") e E - E' tali che v' e V' e v " G V" è un taglio in G. Per la minimalità dell'albero T, per qualunque arco e' ^ e in tale insieme vale che YV(e') ^ W(e): se così non fosse, infatti, l'insieme di archi E' — {e} U {e'} indurrebbe un diverso albero ricoprente di peso W(T) — W(e) + W(e') < W(T). Al tempo stesso, con la stessa motivazione, dato un qualunque taglio in G, l'arco di peso minimo in tale taglio deve essere incluso nel minimo albero ricoprente. Per quanto riguarda la seconda proprietà, per ogni arco e 0 E', l'insieme E' U {e} induce un ciclo che include tale arco: se in tale ciclo esistesse un arco e' € E' tale che W(e') > W(e) allora l'insieme di archi E' — {e'} U {e} indurrebbe un diverso albero ricoprente di peso W(T) — W(e') + W(e) < W(T), pervenendo a una contraddizione. Al tempo stesso, se e è l'arco di peso massimo in un ciclo, non può appartenere a E': se così fosse, potremmo sostuirlo con uno del ciclo meno pesante, ottenendo per assurdo un albero di ricoprimento di costo inferiore al minimo. Nel seguito introduciamo due algoritmi classici risalenti a metà degli anni '50, l'algoritmo di Kruskal e quello di Jarnik-Prim, per la ricerca del minimo albero ricoprente di

un grafo. Prima di esaminarli, preannunciamo però che, in effetti, essi sono due varianti di un medesimo approccio generale alla risoluzione del problema. In questo approccio, un algoritmo opera in modo goloso, inizializzando E' all'insieme vuoto, e aggiungendo poi archi a tale insieme fino a che il grafo T = (V, E') non diventa connesso. Un arco viene aggiunto a E' se è quello più leggero uscente da una qualche componente connessa di T, vale a dire se è l'arco più leggero che collega un nodo della componente a un nodo non appartenente a essa. Per quanto detto sopra, quindi, un arco è incluso nel minimo albero ricoprente se è più leggero di un qualunque taglio che separa la componente dal resto del grafo. L'effetto di tutto ciò è che, a ogni passo, gli archi in E' formano un sottoinsieme (una foresta, in effetti) del minimo albero di ricoprimento. Dato che l'algoritmo termina quando tutti gli archi sono stati esaminati, ne deriva che per ogni taglio esiste almeno un arco (il più leggero, in particolare) che è stato inserito in E' e quindi il grafo T = (V, E') è connesso. Inoltre, dato che per ogni arco inserito in E' due componenti connesse disgiunte di T vengono riunite e che, a partire da n componenti disgiunte (i singoli nodi) per giungere ad avere un singola componente di n nodi bisogna effettuare n — 1 tali operazioni di riunione, ne deriva che il numero di archi in E' al termine dell'algoritmo è pari a n — 1 e che, quindi, T è un albero (essendo connesso e aciclico per costruzione).

8.4.2

Algoritmo di Kruskal

L'algoritmo di Kruskal per la ricerca del minimo albero di ricoprimento opera considerando gli archi l'uno dopo l'altro, in ordine crescente di peso, valutando se inserire ogni arco nell'insieme E' degli archi dell'albero. Nel considerare l'arco (u, v), possiamo avere due possibilità: 1. i due nodi u e v sono già collegati in G = (V, E'), e quindi l'arco (u,v) chiude un ciclo: in tal caso esso è l'arco più pesante nel ciclo, e quindi non appartiene al minimo albero di ricoprimento; 2. i due nodi u e v non sono già collegati in G = (V, E'), e quindi esiste almeno un taglio che separa u da v: di tale taglio (u., v), essendo il primo arco considerato, e il più leggero, e quindi esso appartiene all'albero e va messo in E'. L'algoritmo di Kruskal opera a partire da una situazione in cui esistono n componenti connesse distinte (gli n nodi isolati), ognuna con un proprio minimo albero di ricoprimento (l'insieme vuoto degli archi). L'algoritmo unisce man mano coppie di componenti disgiunte, mantenendo al tempo stesso traccia del minimo albero di ricoprimento della componente risultante. AI termine dell'esecuzione, tutte le componenti sono state riunificate in una sola, il cui minimo albero ricoprente è quindi il minimo albero ricoprente dell'intero grafo.

Kruskal( ) : FOR (u = 0; u < n; u = u + 1) { FOR (x = listaAdiacenza[U].inizio ; x != null; x = x.succ) { v = x.dato; elemento.dato = ; elemento.peso = x.peso; PQ.Enqueue( elemento );

> set[u] = NuovoNodo( ); Crea( set[u] );

> WHILE (!PQ.Empty( )) {

elemento = PQ.Dequeue( ); = elemento.dato ; IF (¡Appartieni( set[u], set[v] )) { Unisci( set[u], set [v] ); mst.InserisciFondo( );

> Codice 8.10

Algoritmo di Kruskal per la ricerca del minimo albero di ricoprimento.

Il Codice 8.10 presenta un'implementazione dettagliata dell'algoritmo delineato sopra e codice vengono utilizzate diverse strutture di dati: 1. una coda con priorità PQ contenente l'insieme degli archi del grafo e i loro pesi; 2. una struttura di dati che rappresenta una partizione dell'insieme dei nodi in modo tale dà consentire di verificare se due nodi appartengono allo stesso sottoinsieme e da effettuare l'unione dei sottoinsiemi di appartenenza di due elementi: a tal fine, utilizziamo un insieme di liste, così come illustrato nel Paragrafo 3.4.1; 3. un array s e t che associa a ogni nodo del grafo un riferimento al corrispondente elemento nella struttura di dati precedente; 4. una lista doppia m s t (come definita nel Paragrafo 5.2) utilizzata per memorizzare gli archi nel minimo albero ricoprente, quando sono individuati dall'algoritmo. Come possiamo vedere, l'algoritmo utilizza la coda con priorità per ottenere un ordinamento degli archi crescente rispetto al loro peso. In particolare, viene inizialmente creata una coda con priorità contenente tutti gli archi, oltre a una rappresentazione

di componenti composte da liste disgiunte, ciascuna inizialmente contenente un solo nodo u (righe 2-11). Gli archi vengono poi considerati l'uno dopo l'altro, in ordine crescente di peso (righe 12-19): per ogni arco, ci chiediamo se esso collega due nodi posti in componenti diverse o, equivalentemente, se chiude un ciclo. Se ciò non avviene e, quindi, l'arco ha peso minimo su un qualunque taglio che divide le due componenti, tali componenti sono unificate e l'arco viene inserito nel minimo albero di ricoprimento (righe 15—18). Notiamo che, essendo il grafo non orientato, ogni arco viene inserito due volte nella coda con priorità senza pregiudicare l'esito dell'algoritmo quando viene estratto due volte (la prima estrazione soltanto può sortire un effetto in quanto la seconda non supera la condizione alla riga 15). Per valutare il tempo di esecuzione dell'algoritmo di Kruskal, possiamo vedere che, su un grafo di n nodi e m archi, esso effettua al più m operazioni E n q u e u e , Empty e D e q u e u e , oltre a n operazioni C r e a , U n i s c i e m operazioni A p p a r t i e n i : il costo dell'algoritmo dipende quindi dai costi di esecuzione di tali operazioni sulle strutture di dati utilizzate. Se ad esempio utilizziamo uno heap come implementazione della coda con priorità e l'insieme di liste del Paragrafo 3.4.1 per rappresentare partizioni di nodi, abbiamo che E n q u e u e e D e q u e u e richiedono tempo O(logn), Empty, A p p a r t i e n i e C r e a in tempo 0 ( 1 ) , e A p p a r t i e n i in tempo O(logn) ammortizzato. Da ciò deriva che il costo complessivo dell'algoritmo in tal caso è O f m l o g m + n l o g n ) = 0 ( ( m + n) logn), e quindi O ( m l o g n ) se il grafo è connesso, per cui abbiamo m ^ n . ALVIE:

algoritmo di Kruskal

Osserva, sperimenta e verifica

Kruskal

8.4.3

Algoritmo di Jarnik-Prim

Come abbiamo visto, l'algoritmo di Kruskal costruisce un minimo albero ricoprente facendo crescere un insieme di minimi alberi ricoprenti relativi a sottoinsiemi dei nodi: gli alberi sono man mano unificati fino a ottenere quello relativo all'intero grafo.

L'algoritmo di Jarnik-Prim opera in modo più "centralizzato": esso parte da un qualunque nodo s e fa crescere un minimo albero ricoprente a partire da tale nodo, aggiungendo man mano nuovi nodi e archi all'albero stesso: se T indica la porzione di minimo albero ricoprente attualmente costruita, l'algoritmo sceglie l'arco (u,v) tale che esso è di

8.4 Opus libri: data mining e minimi alberi ricoprenti

peso minimo nel taglio tra u e T e v € V — T, aggiungendo v a T e (u,v) all'insieme E', fino a coprire tutti i nodi del grafo. Non è difficile renderci conto che l'insieme E' ottenuto al termine dell'algoritmo è l'insieme degli archi nel minimo albero ricoprente. Infatti, ogni arco aggiunto a E' è il più leggero nel taglio che separa T da V — T e quindi, per quanto detto sopra, deve far parte del minimo albero ricoprente del grafo. Dato che, inoltre, al termine dell'algoritmo abbiamo che | E' |= n — 1, tutti gli archi dell'albero compaiono in E'. Come implementare in modo efficiente l'algoritmo presentato sopra? Il punto critico di un'implementazione è rappresentato dal come realizzare efficientemente la selezione dell'arco di peso minimo tra T a V — T. La soluzione banale, consistente nell'effettuare tale selezione scandendo ogni volta tutti gli m archi porterebbe a ottenere un tempo di esecuzione O ( n m ) , peggiore quindi di quello ottenuto dall'algoritmo di Kruskal. Una soluzione più efficiente è fornita dall'utilizzo di una coda con priorità PQ all'interno della quale mantenere, a ogni istante, l'insieme dei nodi in V—T, utilizzando come peso di ogni nodo v e V — T il peso dell'arco più leggero che collega v a un qualche nodo in T. Se ad esempio consideriamo la situazione rappresentata nel primo grafo nella Figura 8.7, osserviamo che V — T = {v2, vg, V7, vg} e che i pesi associati a ognuno di tali nodi saranno, rispettivamente, 8, +00, 7, 14, dove il peso +00 per il nodo v<$ sta a rappresentare il fatto che tale nodo non è adiacente a nessun nodo di T.

Jarnik-Prim( ): FOR (u = 0; u < n; u = u + 1) { incluso[u] = FALSE; pred [u] = u; elemento.peso = peso[u] = +oo; elemento.dato = u; PQ.Enqueue( elemento );

> WHILE (!PQ.Empty( )) {

elemento = PQ.Dequeue( ); v = elemento.dato; incluso[v] = TRUE; mst.InserisciFondoC ); FOR (X = listaAdiacenza[v].inizio; x != null; x = x.succ) { u = x.dato; IF (!incluso[u] && x.peso < peso[u]) { pred[u] = v; peso[u] = x.peso; PQ.DecreaseKeyC u, peso[u] );

> > Codice 8.11

Algoritmo di Jarnik-Prim per la ricerca del minimo albero di ricoprimento.

Utilizzando una coda con priorità di questo tipo, la selezione dell'arco viene effettuata mediante una D e q u e u e , ma, al tempo stesso, è necessario prevedere l'aggiornamento, quando necessario, dei pesi associati ai nodi in PQ. Tale aggiornamento può derivare dal passaggio di un nodo v da V —T a T, passaggio che fa sì che modifichiamo l'insieme degli archi tra T e V — T considerati per la selezione. Ad esempio, nel passaggio dalla situazione considerata sopra alla situazione successiva, descritta dal secondo grafo nella figura, abbiamo che, per effetto del passaggio del nodo v j da V — T a T, il nodo vg risulta ora adiacente a un nodo in T (V7 stesso), e quindi il peso associato a vg in PQ viene decrementato da +00 a 17 = Wfv^, V7). Se consideriamo la situazione successiva (descritta dal terzo grafo nella figura) possiamo vedere come, per effetto del passaggio in T di V2 adiacente anch'esso a vg, l'arco più leggero che collega tale nodo a un qualche altro nodo in T sia (v2,vg), e quindi, a questo punto, il peso associato a Vg in PQ è pari a W(v2, vg) = 8. Da quanto osservato, possiamo concludere che l'utilizzo di PQ richiede che, in corrispondenza a ogni passaggio di un nodo v da T a V —T, vengano esaminati tutti gli i archi

incidenti v. Per ogni arco (u, v) di questo tipo, se u e V — T allora il peso di u in PQ viene posto pari a W ( u , v), se tale valore è minore del peso attuale di u . In tal modo, se esiste ora un modo "più economico" per collegare un nodo in T a V — T, ciò viene riportato nella coda con priorità. Quindi, le operazioni che vanno effettuate su PQ sono quindi E n q u e u e per costruire la coda, D e q u e u e per estrarre man mano i nodi da inserire in T e D e c r e a s e K e y per aggiornare il peso dei nodi ancora in T (notiamo che l'aggiornamento può essere soltanto un decremento). Il Codice 8.11 realizza tale strategia impiegando un array booleano i n c l u s o per marcare i vertici in T, mentre quelli in V — T sono nella coda con priorità PQ (l'inizializzazione è alle righe 2 - 8 ) . Nel ciclo principale (righe 9 22), l'algoritmo estrae il nodo v da includere in T e decrementa il peso dei suoi vertici adiacenti u in V — T, quando questi hanno peso superiore a quello dell'arco (v, u) che li collega a v. L'algoritmo esegue in particolare n operazioni E n q u e u e e D e q u e u e , e al più 2 m operazioni D e c r e a s e K e y , e il suo costo, come nei casi precedenti degli algoritmi di Dijkstra e di Kruskal, dipende dal costo di tali operazioni sull'implementazione della coda con priorità adottata. Ad esempio, utilizzando uno heap abbiamo, come già visto, che le tre operazioni in questione hanno ciascuna costo O(logn), per cui il costo complessivo dell'algoritmo risulta 0 ( ( n + m) logn), e quindi O ( m l o g n ) in quanto consideriamo il grafo connesso: l'utilizzo di uno heap di grado d > 2 ha come conseguenza, così come per l'algoritmo di Dijkstra, che il costo risulta 0 ( m l o g T n y n n ) . Infine, l'utilizzo di heap di Fibonacci (che, ricordiamo, hanno costi ammortizzati per le operazioni Enqueue, Dequeue e D e c r e a s e K e y pari a 0 ( 1 ) , O(logn) e 0 ( 1 ) , rispettivamente) fasi che il costo complessivo dell'algoritmo risulti 0 ( n l o g n - | - m), migliore quindi di quanto ottenuto per mezzo dall'algoritmo di Kruskal. ALVIE:

algoritmo di Jarnik-Prim

Osserva, sperimenta e verifica Jarnik-Prim

RIEPILOGO In questo capitolo abbiamo esaminato le code con priorità, mostrandone e discutendone l'implementazione più diffusa, lo heap. Abbiamo illustrato l'applicazione delle code con priorità a vari importanti problemi, come l'ordinamento, per il quale abbiamo considerato l'algoritmo di heapsort, la ricerca di cammini minimi e la derivazione del minimo albero ricoprente in grafi pesati. Per tali problemi, che rivestono grande rilevanza applicativa, abbiamo mostrato diverse soluzioni algoritmiche, sia facenti uso di code con priorità che operanti senza utilizzare tali strutture.

ESERCIZI 1. Mostrate come ottenere una coda con priorità con la stessa complessità in tempo dello heap, utilizzando un albero AVL (descrivete anche come realizzare la funzione D e c r e a s e K e y ) . Discutete complessità in spazio. 2. Un min-max heap è una struttura di dati che implementa una coda con priorità sia rispetto al minimo che rispetto al massimo. In uno heap di questo tipo, nella radice è contenuto il minimo e, in ognuno dei suoi due figli, il massimo tra gli elementi presenti nel relativo sottoalbero. In generale, i nodi nell'i-esimo livello dall'alto (dove assumiamo che la radice è a livello 1) contengono gli elementi minimi nei relativi sottoalberi, se i è dispari, e gli elementi massimi, se i è pari. Implementate tale struttura con le operazioni E n q u e u e , E x t r a c t M i n , E x t r a c t M a x , che inseriscono un elemento ed estraggono il minimo e il massimo, rispettivamente. 3. Nella trattazione dell'algoritmo di Dijkstra abbiamo implicitamente supposto che tra ogni coppia di nodi esista un solo cammino minimo. Dimostrate che la correttezza e l'efficienza dell'algoritmo valgono anche nel caso generale in cui possono esistere più cammini minimi tra due nodi. Mostrate anche che i cammini selezionati dall'algoritmo tramite l'array p r e d formano un albero dei cammini minimi con radice nel nodo di partenza s. 4. Implementate uno heap di grado predefinito d > 2: a tal fine, prevedete una funzione C r e a ( d ) che crea uno heap del grado specificato. 5. Mostrate come utilizzare l'algoritmo di Dijkstra per determinare, dato un nodo v, il ciclo semplice di lunghezza minima che include tale nodo. Implementate quindi un algoritmo per ottenere il girovita (girth) di un grafo, vale a dire la lunghezza del ciclo semplice di lunghezza minima nel grafo stesso. 6. Modificate il codice dell'algoritmo di Bellman-Ford per verificare la presenza di cicli negativi, cosi come illustrato nel testo. 7. Implementate un semplice algoritmo di clustering basato sul minimo albero di ricoprimento. L'algoritmo, dato un insieme S di punti in uno spazio a d = 3 dimensioni, suddivide tale insieme in k cluster, dove k è un parametro passato all'algoritmo stesso. 8. Fornite un controesempio per mostrare che gli algoritmi di Kruskal e Jamik-Prim non calcolano sempre correttamente l'albero minimo di ricoprimento per un grafo orientato.

Capitolo 9

NP-completezza

SOMMARIO In questo capitolo finale riprendiamo in esame le classi di complessità introdotte nel primo capitolo, dandone una definizione formale basata sul concetto di problema decisionale e su quello di verifica di una soluzione. Introduciamo inoltre il concetto di riduzione polinomiale e quello di problema NP-completo, dimostrando la NP-completezza di alcuni problemi computazionali esaminati nel resto del libro e fornendo alcuni suggerimenti su come dimostrare un nuovo risultato di NP-completezza. Infine, mostriamo come affrontare la difficoltà computazionale intrinseca di un problema facendo uso di algoritmi polinomiali di approssimazione: forniamo un tale algoritmo per il problema del ricoprimento tramite vertici e per quello del commesso viaggiatore ristretto a istanze metriche e mostriamo come, in generale, quest'ultimo problema non ammetta algoritmi di approssimazione ma possa essere risolto, in pratica, mediante euristiche basate sul paradigma della ricerca locale. DIFFICOLTÀ 1,5 CFU

9.1

Problemi NP-completi

Abbiamo più volte incontrato nei capitoli precedenti problemi per i quali non conosciamo algoritmi di risoluzione polinomiali, ma per i quali non siamo neanche in grado di dimostrare che tali algoritmi non esistano. In particolare, nel primo capitolo abbiamo introdotto il problema del gioco del Sudoku, per poi considerare nel capitolo successivo i problemi della partizione di numeri interi e della bisaccia e, nel quinto capitolo, i problemi della colorazione di grafi e della ricerca del massimo insieme indipendente. In tutti questi casi, abbiamo detto che i problemi erano NP-completi, intendendo con questo termine problemi per i quali, nonostante gli sforzi ripetuti di molti ricercatori, non

conosciamo algoritmi di risoluzione polinomiale e tali che se uno solo di essi è risolvibile in tempo polinomiale, allora ogni problema NP-completo è risolvibile in tempo polinomiale. Per questo motivo, è opinione diffusa che un problema NP-completo non può essere risolto in tempo polinomiale, anche se non conosciamo ancora una dimostrazione di tale affermazione. Il concetto di problema NP-completo consente di affrontare la risoluzione di un problema computazionale da due punti di vista complementari. Da un lato, il nostro obiettivo è chiaramente quello di progettare un algoritmo di risoluzione efficiente per il problema in esame: le strutture di dati e i paradigmi algoritmici discussi in questo libro sono gli strumenti più adatti per tentare di raggiungere quest'obiettivo. Dall'altro lato, avendo a disposizione la nozione di problema NP-completo, possiamo tentare di dimostrare che quello che stiamo analizzando è, probabilmente, intrinsecamente difficile e che la progettazione di un algoritmo polinomiale per esso sarebbe un risultato con conseguenze molto più significative (ovvero, migliaia di altri problemi risulterebbero improvvisamente risolvibili in tempo polinomiale). Sebbene mostrare l'intrinseca difficoltà di un problema computazionale possa sembrare meno interessante che progettare per esso un algoritmo polinomiale di risoluzione, un risultato di NP-completezza ha l'indubbio vantaggio di far rivolgere i nostri sforzi verso obiettivi meno ambiziosi: come vedremo al termine di questo capitolo, esistono diversi modi per affrontare la difficoltà di un problema NP-completo, tra cui uno dei più esplorati consiste nella progettazione di algoritmi di approssimazione, ovvero algoritmi efficienti le cui prestazioni, in termini di qualità della soluzione calcolata (non necessariamente ottima), siano in qualche modo garantite.

9.1.1

Classi P e NP

Nel primo capitolo abbiamo introdotto in modo informale le classi di complessità P e NP, evidenziando che un problema contenuto nella prima classe ammette un algoritmo di risoluzione efficiente, ovvero polinomiale, mentre un problema contenuto nella seconda classe ammette un algoritmo efficiente di verifica di una soluzione. 1 Per formalizzare queste definizioni, restringiamo la nostra attenzione (per ora) ai soli problemi di decisione, ossia ai problemi la cui soluzione è una risposta binaria — sì o no. Utilizzando i meccanismi di codifica binaria (Paragrafo 1.2.1) delle istanze di un problema decisionale, identifichiamo un problema decisionale con il corrispettivo insieme (potenzialmente infinito) di istanze la cui risposta è "sì": risolvere tale problema consiste quindi nel decidere l'appartenenza di una sequenza binaria all'insieme (osserviamo che non è restrittivo restringersi alle sole sequenze binarie, in quanto il calcolatore stesso ope1

L'acronimo NP sta per non-deterministico polinomiale, motivato storicamente dalla definizione della classe NP usando la macchina di Turing non-deterministica.

ra solo su tale tipo di sequenze). Pertanto, un problema di decisione TT non è altro che un sottoinsieme dell'insieme di tutte le possibili sequenze binarie, in particolare di quelle che soddisfano una determinata proprietà. Ad esempio, il problema di decidere se un dato numero intero è primo consiste di tutte le sequenze binarie che codificano numeri interi primi, per cui la sequenza 1101 (13 in decimale) appartiene a tale problema mentre la stringa 1100 (12 in decimale) non vi appartiene. Il problema di decidere se un grafo può essere colorato con tre colori consiste di tutte le sequenze binarie che codificano grafi che possono essere colorati con tre colori. Nel seguito, per motivi di chiarezza, continueremo a definire un problema decisionale facendo uso di descrizioni formulate in linguaggio naturale, anche se implicitamente intenderemo definirlo come uno specifico insieme di sequenze binarie, facendo riferimento a opportuni meccanismi di codifica (Paragrafo 1.2.1). Un problema decisionale TI appartiene alla classe P se esiste un algoritmo polinomiale A che, presa in ingresso una sequenza binaria x, determina se x appartiene a l l o meno. Ad esempio, sappiamo che il problema di decidere se, dato un grafo (orientato) G e due suoi nodi s e t , esiste un cammino semplice da s a t appartiene a P, in quanto abbiamo visto nel Paragrafo 7.4.1 come visitare tutti i nodi raggiungibili da s operando una visita in ampiezza del grafo: se t è incluso tra questi vertici, allora la risposta al problema è affermativa, altrimenti è negativa. Non sappiamo se il problema di decidere se un grafo può essere colorato con tre colori appartiene a P, ma possiamo mostrare che lo stesso problema ristretto a due colori vi appartiene: a tale scopo, mostriamo come utilizzare il fatto che se un vertice è colorato con il primo colore, allora tutti i suoi vicini devono essere colorati con il secondo colore. L'idea dell'algoritmo consiste nel colorare un vertice i con uno dei due colori e dedurre tutte le colorazioni degli altri vertici che ne conseguono: se riusciamo a colorare tutti i vertici, possiamo concludere che il grafo è colorabile con due colori. Altrimenti, se arriviamo a una contraddizione (ovvero, siamo costretti a colorare un vertice con due colori diversi), possiamo dedurre che il grafo non è colorabile con due colori (in realtà, questo algoritmo deve essere applicato a ogni componente connessa del grafo). Il Codice 9.1 realizza l'algoritmo appena descritto ipotizzando che il grafo in ingresso sia connesso: dopo aver cancellato i colori di tutti i vertici (righe 2 e 3), il codice prova ad assegnare al primo vertice il colore 1 e aggiorna il numero di vertici colorati, memorizzato nella variabile f a t t i (riga 4). Il ciclo w h i l e successivo determina le eventuali conseguenze della colorazione attuale: ogni vertice i viene esaminato all'interno del ciclo f o r alle righe 6 - 2 1 , per vedere se non è già stato colorato (riga 7). In tal caso, il codice controlla se i vicini di i hanno usato entrambi i colori (righe 8-13): se è così, allora abbiamo trovato una contraddizione (riga 15). Se invece i vicini di i hanno usato uno solo dei due colori, l'altro viene assegnato a i stesso (righe 17 e 18): ovviamente, vi

DueColorazione( A ): (pre: A matrice di adiacenza di un grafo connesso di n nodi) FOR (i = 0; i < N; i = i+1) colore [i] c o l o r e [0] WHILE

=

=

( f a t t i

FOR ( i IF

=

-1;

f a t t i <

0;

=

i

N; i

<

(colore[i] usato[0]

=

FOR ( j

0;

IF

=

1;

n)

<

=

0)

i+1)

u s a t o t i ] j

(A[j] [i]

<

{

{

i;

= j

FALSE; =

1 kk

==

u s a t o [ c o l o r e [ j ] ]

j

1) {

+

c o l o r e [ j ] =

>=

0)

{

TRUE;

}

> IF

(usato[0]

kk

u s a t o t i ] )

{

RETURN FALSE; > ELSE { IF

(usato[0])

{

c o l o r e [ i ]

=

1;

f a t t i

=

f a t t i

+

1;

}

IF

( u s a t o t i ] )

{

c o l o r e [ i ]

=

0;

f a t t i

=

f a t t i

+

1;

}

> >

> RETURN

Codice 9.1

TRUE;

Algoritmo per decidere se un grafo connesso è colorabile con due colori.

è anche la possibilità che nessun colore sia stato usato dai vicini di i, nel qual caso non possiamo ancora concludere nulla sulla sua colorazione. Al termine del ciclo w h i l e , se non troviamo una contraddizione, concludiamo che il grafo è colorabile con due colori (in quanto tutti i nodi sono stati colorati): altrimenti deduciamo che non lo è (riga 22). ALVIE:

colorazione di un grafo con due colori

Osserva, sperimenta e verifica TwoColoring

Poiché a ogni iterazione del ciclo w h i l e coloriamo un nuovo nodo oppure incontriamo una contraddizione, abbiamo che il numero di iterazioni eseguite dal ciclo è al più n . Ciascuna iterazione richiede 0 ( n 2 ) tempo, per cui la complessità temporale dell'algoritmo è 0 ( n 3 ) . Facendo riferimento alla rappresentazione mediante liste di adia-

cenza e utilizzando una variante della procedura di visita in ampiezza di un grafo vista nel Paragrafo 7.4.1, possiamo mostrare che tale algoritmo può essere implementato più , efficientemente in tempo 0 ( n + m), dove m indica il numero degli archi del grafo. Migliaia di problemi decisionali appartengono alla classe P e in questo libro ne abbiamo incontrati diversi. Da questo punto di vista, uno dei risultati recenti più interessanti è stato ottenuto dagli indiani Manindra Agrawal, Neeraj Kayal e Nitin Saxena e consiste nella dimostrazione che appartiene a P il problema di decidere se un dato numero intero ( è primo: tale problema aveva resistito all'attacco di centinaia di valenti ricercatori matematici e informatici, senza che nessuno fosse stato in grado di progettare un algoritmo di risoluzione polinomiale o di dimostrare che un tale algoritmo non poteva esistere. La classe P, tuttavia, non esaurisce l'intera gamma dei problemi decisionali: come abbiamo visto nel primo capitolo, esistono molti problemi per i quali non conosciamo un algoritmo di risoluzione polinomiale e ve ne sono diversi per i quali siamo sicuri che tale algoritmo non esiste (come il problema delle torri di Hanoi). Introduciamo ora la classe NP che include, oltre a tutti i problemi in P, molti altri problemi computazionali. Intuitivamente, un problema FI in NP non necessariamente ammette un algoritmo di risoluzione polinomiale, ma è tale che se una sequenza x appartiene a Fi allora deve esistere una dimostrazione breve di questo fatto, la quale può essere verificata in tempo polinomiale. Formalmente, la classe NP include tutti i problemi di decisione Fi per i quali esiste un algoritmo polinomiale V e un polinomio p che, per ogni sequenza binaria x, soddisfano le seguenti due condizioni: completezza: se x appartiene a Fi, allora esiste una sequenza y di lunghezza p(|x|) tale che V con x e y in ingresso termina restituendo il valore TRUE; consistenza: se x non appartiene a FI, allora, per ogni sequenza y, V con x e y in ingresso termina restituendo il valore FALSE. Osserviamo che P è contenuta in NP. Dato un problema FI in P, sia A un algoritmo di risoluzione polinomiale per IT. Possiamo allora definire V nel modo seguente: per ogni x e y, l'algoritmo V con x e y in ingresso restituisce il valore TRUE se A con x in ingresso risponde in modo affermativo, altrimenti restituisce il valore FALSE. Chiaramente, V (assieme a un qualunque polinomio e senza aver bisogno di usare y) soddisfa le condizioni di completezza e consistenza sopra descritte: quindi, Fi appartiene a NP. Non sappiamo, invece, se NP è contenuta in P. Data l'enorme quantità di problemi in NP per i quali non conosciamo un algoritmo polinomiale di risoluzione, la congettura più accreditata è che P sia diversa da NP. Non avendo una dimostrazione di quest'affermazione, possiamo solamente individuare all'interno della classe NP i problemi decisionali che maggiormente si prestano a fungere da problemi "separatori" delle due classi: tali problemi sono i problemi NP-completi, che costituiscono i problemi più difficili all'interno della classe NP.

9.1.2

Riducibilità polinomiale

Per poter definire il concetto di problema NP-completo, abbiamo bisogno della nozione di riducibilità polinomiale. Intuitivamente, un problema di decisione FI è riducibile polinomialmente a un altro problema di decisione FI' se l'esistenza di un algoritmo di risoluzione polinomiale per IV implica l'esistenza di un tale algoritmo anche per IT. Abbiamo già visto come il concetto di riducibilità può essere applicato per dimostrare che un dato problema computazionale è risolvibile in modo efficiente (pensiamo ad esempio al problema del minimo antenato comune analizzato nel Paragrafo 4.2.1). Forniamo ora un ulteriore esempio di tale applicazione considerando il problema della soddisfacibilità ristretto a clausole con due letterali. Sia X = { x o . x i , . . . , x n _ i ) un insieme di n variabili booleane. Una formula booleana in forma normale congiuntiva su X è un insieme C = {co, C i , . . . , c m _ i ) di m clausole, dove ciascuna clausola Ct, per 0 ^ i < m, è a sua volta un insieme di letterali, ovvero un insieme di variabili in X e/o di loro negazioni (indicate con x^). Un'assegnazione di valori per X è una funzione T : X —> {TRUE, FALSE} che assegna a ogni variabile un valore di verità. Un letterale L è soddisfatto da T se L = Xj e X(xj) = TRUE oppure se L = Xj" e x(XJ ) = FALSE, per qualche 0 ^ j < n . Una clausola è soddisfatta da T se almeno un suo letterale lo è e una formula è soddisfatta da T se tutte le sue clausole lo sono. Il problema della soddisfacibilità (indicato con SAT) consiste nel decidere se una formula booleana in forma normale congiuntiva è soddisfacibile. In particolare, il problema 2-SAT è la restrizione di SAT al caso in cui le clausole contengano esattamente due letterali. Per mostrare che 2-SAT è risolvibile in tempo polinomiale, definiamo una riduzione da 2-SAT al problema di decidere se, dato un grafo orientato G e due nodi s e t, esiste un cammino in G da s a t: poiché quest'ultimo problema ammette un algoritmo di risoluzione polinomiale, abbiamo che anche 2-SAT ammette un tale algoritmo. Data un formula booleana cp in forma normale congiuntiva formata da m clausole c o , C i , . . . , c m _ i su n variabili x o , x i , . . . , x n _ i , costruiamo un grafo orientato G = (V, E) contenente 2 n vertici (due per ogni variabile booleana) e 2 m archi (due per ogni clausola). 2 In particolare, per ogni variabile xt, G include due vertici v?°s e v" ee corrispondenti, rispettivamente, ai letterali x\ e x[. Inoltre, per ogni clausola {li, I2} della formula, G include un arco tra il vertice corrispondente a li e quello corrispondente a I2 e un arco tra il vertice corrispondente a I2 e quello corrispondente a lj (Figura 9.1): intuitivamente, questi due archi modellano il fatto che se uno dei due letterali della clausola non è soddisfatto, allora lo deve essere l'altro letterale. Notiamo che il grafo G soddisfa la seguente proprietà: se esiste un cammino tra il vertice corrispondente a un letterale l e il vertice corrispondente a un letterale l ' , allora 2 Senza perdita di generalità, possiamo supporre che nessuna clausola è formata da una variabile e dalla sua negazione: in effetti, una tale clausola è soddisfatta da qualunque assegnazione di valori e può, quindi, essere eliminata dalla formula.

Figura 9.1

Un esempio di riduzione da 2-SAT al problema della ricerca di cammini in un grafo: le clausole sono (x 0 ,x7}, {xo.xj), { x i , x 2 } e {xf,x5}.

esiste un cammino tra il vertice corrispondente a l ' e il vertice corrispondente a T. Ad esempio, nella Figura 9.1, esiste il cammino da VQCg a v ^ (che passa per v" eg ) ed esiste anche il cammino da v ^ 8 a VqOS (che passa per V|0S). Mostriamo ora che cp è soddisfacibile se e solo se, per ogni variabile Xi con 0 ^ i < n, abbiamo che v" eg non è raggiungibile da vP°s e v?°s non è raggiungibile da v" eg (ovvero, se non vi sono contraddizioni in cp). Sia T un'assegnazione di verità che soddisfa cp e supponiamo, per assurdo, che esista una variabile Xi tale che v" eg è raggiungibile da v?os e che v?os è raggiungibile da v" eg : supponiamo che t ( x ì . ) = T R U E (possiamo gestire il caso opposto in modo simile). Poiché esiste un cammino da v?os a v" eg e poiché T soddisfa x^ ma non soddisfa x^, deve esistere un arco (p, q) di tale cammino tale che il letterale l p a cui corrisponde p è soddisfatto mentre il letterale l q a cui corrisponde q non lo è: per definizione di G, cp include la clausola {l p , l q } la quale non è soddisfatta da t , contraddicendo l'ipotesi. Viceversa, supponiamo che, per ogni variabile x^ con 0 ^ i < n , v" eg non è raggiungibile da v?os oppure v?°s non è raggiungibile da v" eg , e mostriamo come costruire un'assegnazione di valori T che soddisfa cp ripetendo il seguente procedimento fino a quando a tutte le variabili abbiamo assegnato un valore (notiamo la similitudine tra questo procedimento e l'algoritmo per decidere se un grafo è colorabile con due colori). Sia l un letterale alla cui variabile corrispondente non abbiamo assegnato un valore e tale che il vertice p corrispondente a I non è raggiungibile dal vertice q corrispondente a l (per ipotesi, tale letterale deve esistere se vi sono ancora variabili a cui non abbiamo assegnato un valore). Estendiamo T in modo da soddisfare tutti i letterali a cui corrispondono vertici raggiungibili da q e in modo da non soddisfare tutti i letterali a cui corrispondono vertici raggiungibili da p. Tale estensione dell'assegnazione non crea contraddizioni, in quanto se i vertici corrispondenti a un letterale e alla sua negazione fossero entrambi raggiungibili da q, allora

(per simmetria) p sarebbe da essi raggiungibile e, quindi, esisterebbe un cammino da q a p. Inoltre, se un letterale l ' corrispondente a un vertice raggiungibile da q fosse già stato non soddisfatto in un passo precedente, allora p sarebbe raggiungibile dal vertice corrispondente alla negazione di L' e, quindi, T avrebbe già assegnato un valore alla variabile corrispondente a l. Poiché a ogni passo, estendiamo T soddisfacendo l e tutti i letterali che corrispondono a vertici raggiungibili da q, abbiamo che al termine del procedimento non può esistere un arco (r, s) tale che il letterale a cui corrisponde r è soddisfatto mentre quello a cui corrisponde s non lo è. Quindi, T soddisfa tutte le clausole. Nel caso del grafo mostrato nella Figura 9.1, possiamo scegliere l = Vq0S, in quanto 66 VQ non è raggiungibile da VgOS. Quindi, estendiamo l'assegnazione T (attualmente vuota) in modo da soddisfare tutti i letterali a cui corrispondono vertici raggiungibili da VqOS, che sono v" eg e v^ 05 . Pertanto, T(X 0 ) = T R U E , T(XI ) = T R U E e T(X 2 ) = FALSE. Poiché a ogni variabile abbiamo assegnato un valore, il procedimento ha termine: in effetti, T soddisfa le quattro clausole {xo, xì~}, {xo, X2}, {xj, x 2 } e {xì~, X2}.

9.1.3

Problemi NP-completi

In questo capitolo, siamo principalmente interessati a utilizzare il concetto di riducibilità per ottenere risultati negativi piuttosto che positivi, ovvero per dimostrare che un problema non è risolvibile facendo uso di risorse temporali limitate. Un semplice esempio di tale applicazione consiste nel dimostrare che il problema geometrico del minimo insieme convesso ha, in generale, una complessità temporale n ( n l o g n ) . Tale problema consiste nel trovare, dato un insieme di punti sul piano, il più piccolo (rispetto all'inclusione insiemistica) insieme convesso S che li contiene tutti: 3 nella Figura 9.2 mostriamo due esempi di insiemi convessi di cardinalità minima. Un punto p e S è un estremo di S, se esiste un semipiano passante per p tale che p è l'unico punto che giace sulla retta che delimita il semipiano: il problema del minimo insieme convesso consiste nel calcolare gli estremi di S come una lista (ciclicamente) ordinata di punti (ad esempio, la soluzione nella parte sinistra della Figura 9.2 è data da Po. Pi - P2 e P3). Notiamo che se i punti dell'istanza del problema giacciono su una parabola (come nella parte destra della Figura 9.2), allora la soluzione al problema del minimo insieme convesso consiste nella lista dei punti ordinata in base alle loro ascisse. Questa osservazione ci permette di ridurre il problema dell'ordinamento di n numeri interi Qo, d i , . . . , a n _ i a quello del calcolo del minimo insieme convesso nel modo seguente: per ogni i con 0 ^ i ^ n — 1, definiamo un punto di coordinate (ai, a?). Chiaramente, gli n punti cosi costruiti giacciono sulla parabola di equazione y = x 2 e quindi il loro 'Ricordiamo che un un insieme S è detto convesso se, per ogni coppia di punti in S, il segmento che li unisce è interamente contenuto in S.

Figura 9.2

Due esempi di minimo insieme convesso.

minimo insieme convesso consiste nel loro elenco ordinato in base alle loro ascisse: tale elenco è dunque l'ordinamento degli n numeri interi. Poiché la costruzione suddetta può essere eseguita in tempo O(n), se il problema del minimo insieme convesso è risolvibile in tempo o ( n l o g n ) , allora anche il problema dell'ordinamento di n numeri interi è risolvibile in tempo o ( n l o g n ) : nel Paragrafo 2.5.3 abbiamo visto che ciò non è in generale possibile, per cui abbiamo appena dimostrato un limite inferiore alla complessità temporale del problema del minimo insieme convesso. In generale, se un problema TI è riducibile polinomialmente a un problema f i ' e se sappiamo che IT non ammette un algoritmo di risoluzione polinomiale, allora possiamo concludere che neanche Fi' ammette un tale algoritmo. In altre parole, IT' è almeno tanto difficile quanto IT (notiamo che l'uso "positivo" del concetto di riducibilità consiste nell'affermare che FI è almeno tanto facile quanto IT'): quindi, le cattive notizie, ovvero, la non trattabilità di un problema, si propagano da sinistra verso destra (mentre le buone notizie lo fanno da destra verso sinistra). Per definire la nozione di NP-completezza, introduciamo una restrizione del concetto di riducibilità in cui ogni istanza del problema di partenza viene trasformata in un'istanza del problema di arrivo, in modo che le due istanze siano entrambe positive oppure entrambe negative. Formalmente, un problema IT è polinomialmente trasformabile in un problema Fi' se esiste un algoritmo polinomiale T tale che, per ogni sequenza binaria x, vale x e Fi se e solo se T con x in ingresso restituisce una sequenza binaria in Fi'. Chiaramente, se IT è polinomialmente trasformabile in TI', allora Fi è polinomialmente

riducibile a II': infatti, se esiste un algoritmo polinomiale A di risoluzione per Fi', allora la composizione di T con A fornisce un algoritmo polinomiale di risoluzione per TI. Un problema di decisione FI è NP-completo se FI appartiene a NP e se ogni altro problema in NP è polinomialmente trasformabile in FI. Quindi, FI è almeno tanto difficile quanto ogni altro problema in NP: in altre parole, se dimostriamo che Fi è in P, allora abbiamo che l'intera classe NP è contenuta in P (e quindi le due classi coincidono). E naturale a questo punto chiedersi se esistono problemi NP-completi (anche se il lettore avrà già intuito la risposta a tale domanda). Inoltre, se P / NP, possono esistere problemi che né appartengono a P e né sono NP-completi (un possibile candidato di questo tipo è il problema aperto dell'isomorfismo tra grafi, discusso nel Capitolo 6, del quale non conosciamo un algoritmo polinomiale di risoluzione e nemmeno una dimostrazione di NP-completezza). Prima di discutere l'esistenza di un problema NP-completo, però, osserviamo che una volta dimostratane l'esistenza, possiamo sfruttare la proprietà di transitività della trasformabilità polinomiale per estendere l'insieme dei problemi siffatti. La definizione di trasformabilità soddisfa infatti la seguente proprietà: se FIQ è polinomialmente trasformabile in F[[ e Fii è polinomialmente trasformabile in IT2, allora Fio è polinomialmente trasformabile in FI2. A questo punto, volendo dimostrare che un certo problema computazionale FI è NP-completo, possiamo procedere in tre passi: prima dimostriamo che FI appartiene a NP mostrando l'esistenza del suo certificato polinomiale; poi individuiamo un altro problema Fi', che già sappiamo essere NP-completo; infine, trasformiamo polinomialmente Fi' in FI.

9.1.4

Teorema di Cook-Levin

Per applicare la strategia sopra esposta dobbiamo necessariamente trovare un primo problema NP-completo. Il teorema di Cook-Levin afferma che SAT è NP-completo. Osserviamo che SAT appartiene a NP, in quanto ogni formula soddisfacibile ammette una dimostrazione breve e facile da verificare che consiste nella specifica di un'assegnazione di valori che soddisfa la formula. La parte difficile del teorema di Cook-Levin consiste, quindi, nel mostrare che ogni problema in NP è polinomialmente trasformabile in SAT. Non diamo la dimostrazione del suddetto teorema, ma ci limitiamo a fornire una breve descrizione dell'approccio utilizzato. Dato un problema Fi e NP, sappiamo che esiste un algoritmo polinomiale V e un polinomio p tali che, per ogni sequenza binaria x, se x Fi, allora esiste una sequenza y di lunghezza p(|x|) tale che V con x e y in ingresso termina restituendo il valore TRUE, mentre se x £ FI, allora, per ogni sequenza y, V con x e y in ingresso termina restituendo il valore FALSE. L'idea della dimostrazione consiste nel costruire, per ogni x, in tempo polinomiale una formula booleana cpx le cui uniche variabili libere sono p(|x|) variabili yo,yi>• • • >y p (|x|)-i> intendendo con ciò che la soddisfacibilità della formula dipende solo dai valori assegnati a tali variabili:

intuitivamente, la variabile y i corrisponde al valore del bit in posizione i all'interno della sequenza y. La formula ' in forma normale congiuntiva, tale che VJ | è soddisfacibile se e solo se è soddisfacibile. Sappiamo che G = (V, E) può essere rappresentato mediante la matrice di adiacenza A tale che A[i][j] = 1 se e solo se (i, j) S E. A tale matrice facciamo corrispondere n x n variabili booleane ciy e usiamo in (pc le seguenti formule booleane, per 0 ^ i, j < n:

(in altre parole, queste formule forzano le variabili a y a rappresentare la matrice di adiacenza di G). Per ogni vertice i € V, introduciamo poi tre variabili booleane Ti, gt e bi che corrispondono ai tre possibili colori che possono essere assegnati al vertice (quindi, queste sono le variabili libere i cui valori di verità forniscono la dimostrazione y). Per impedire che due colori vengano assegnati allo stesso vertice, usiamo in epe le seguenti formule booleane, per 0 < i < n: Bi = (ri A gt A bi) V (i\ A gt A bt) V (fi A gì A bi) Infine, per verificare che l'assegnazione dei colori ai vertici sia compatibile con gli archi del grafo, epe usa le seguenti formule booleane, per 0 ^ i, j < n: Ci,j = Qi.j =• [(r t A Tj") V ( g t A g^) V (b t A b, )] = o I J V ( n A r f l V ( g i Ag[) V (b t A b , ) (informalmente, C y afferma che se vi è un arco tra i due vertici i e j, allora questi due vertici non possono avere lo stesso colore). In conclusione, la formula
Ai,jA

f\

BiA

/\

Ci,,

Chiaramente, epe è soddisfacibile se e solo se i vertici di G possono essere colorati con tre colori. Il teorema di Cook-Levin afferma sostanzialmente che quanto abbiamo appena fatto per il problema della colorazione può in realtà essere fatto per qualunque problema in N P . Notiamo che la NP-completezza di SAT non implica che il problema della soddisfacibilità di formule booleane in forma normale disgiuntiva sia anch'esso NP-completo: se una formula è in forma normale disgiuntiva, allora una clausola è soddisfatta da un'assegnazione di valori T se tutti i suoi letterali lo sono e la formula è soddisfatta da T se almeno una sua clausola lo è. In tal caso, possiamo mostrare che il problema della soddisfacibilità è risolvibile in tempo polinomiale e, quindi, non è molto probabilmente NP-completo.

9.1.5

Problemi di ottimizzazione

Prima di passare a dimostrare diversi risultati di NP-completezza, introduciamo il concetto di problema di ottimizzazione, inteso in qualche modo come estensione di quello di problema decisionale. In un problema di ottimizzazione, a ogni istanza del problema associamo un insieme di soluzioni possibili e a ciascuna soluzione associamo una misura (che può essere un costo oppure un profitto): il problema consiste nel trovare, data un'istanza, una soluzione ottima, ovvero una soluzione di misura minima se la misura è un costo, una di misura massima altrimenti. Abbiamo già incontrato diversi problemi di ottimizzazione nei capitoli precedenti (ad esempio, il problema della sequenza ottima di moltiplicazioni di matrici del Paragrafo 2.6.2 oppure quello della sotto-sequenza comune più lunga del Paragrafo 2.7.1). Osserviamo che a ogni problema di ottimizzazione corrisponde in modo abbastanza naturale un problema di decisione definito nel modo seguente: data un'istanza del problema e dato un valore k, decidere se la misura della soluzione ottima è inferiore a k (nel caso di costi) oppure superiore a k (nel caso di profitti). Nella maggior parte dei problemi di ottimizzazione che sorgono nella realtà, abbiamo che se il corrispondente problema di decisione è risolvibile in tempo polinomiale, allora anche il problema di ottimizzazione è risolvibile in tempo polinomiale. Ciò è principalmente dovuto al fatto che il valore massimo che la misura di una soluzione può assumere è limitato esponenzialmente dalla lunghezza dell'istanza: questa osservazione ci consente di ridurre polinomialmente un problema di ottimizzazione al suo corrispondente problema di decisione, operando in base a un meccanismo simile a quello di ricerca binaria descritto nel Paragrafo 2.4.1. Quindi, se il problema di decisione associato a un problema di ottimizzazione è NP-completo, abbiamo che quest'ultimo non può essere risolto in tempo polinomiale a

meno che P = NP: nel paragrafo finale di questo capitolo, analizzeremo in dettaglio uno dei più famosi problemi di ottimizzazione intrinsecamente difficili.

9.2

Esempi e tecniche di NP-completezza

A partire da SAT, mostriamo ora come sia possibile verificare la NP-completezza di altri problemi computazionali: alcuni che abbiamo esaminato nei capitoli precedenti e che abbiamo dichiarato essere NP-completi e altri che useremo come problemi di passaggio nelle catene di trasformazioni polinomiali. Per prima cosa, dimostriamo che la restrizione 3-SAT di SAT a clausole formate da esattamente tre letterali è anch'esso un problema NP-completo (chiaramente 3-SAT è in NP per lo stesso motivo per cui lo è SAT).

9.2.1

Tecnica di sostituzione locale

Sia C = { c o , . . . , c m _ i } un insieme di m clausole costruite a partire dall'insieme X di variabili booleane {xo,... , x n i). Vogliamo costruire, in tempo polinomiale, un nuovo insieme D di clausole, ciascuna di cardinalità 3, costruite a partire da un insieme Z di variabili booleane e tali che C è soddisfacibile se e solo se D è soddisfacibile. A tale scopo usiamo una tecnica di trasformazione detta di sostituzione locale, in base alla quale costruiremo D e Z sostituendo ogni clausola c S C con un sottoinsieme D c di D in modo indipendente dalle altre clausole di C: l'insieme D è quindi uguale a U c 6 c D c e Z è l'unione di tutte le variabili booleane che appaiono in D. Data una clausola c = { l o , . . . , l k - i ) dell'insieme C, definiamo D c distinguendo i seguenti quattro casi: 1. k = 1: in questo caso, D c = { { l o . U o ' y i K U o . y o ' y Ì ^ ^ ' y o ' y Ì ^ ^ O ' y o ' y i W (chiaramente D c è soddisfacibile se e solo se lo è soddisfatto); 2. k = 2: in questo caso, D c = {{lo>li>yo}>{lo>t-i>yo} (chiaramente D c è soddisfacibile se e solo se lo oppure li è soddisfatto); 3. k = 3: in questo caso, D c è formato dalla sola clausola c; 4. k > 3: in questo caso, che è il più difficile, l'insieme D c contiene un insieme di k — 2 clausole collegate tra di loro attraverso nuove variabili booleane e tali che la loro soddisfacibilità sia equivalente a quella di c. Formalmente, D c è l'insieme {{io.ii,yo}.{yo'l2-yi}.{yi.l3.y2}.---'{yk-5.lic-3.yk-4}'{yk-4'lk-2.W-i}

Dalla definizione di D c abbiamo che Z = XU

U c6CA|c| = l

{y 0 c ,yi}u

U c€CA|c|=2

{yS)u

U

{y§,...,yfcl_4}

ceCA|c|>3

e che la costruzione dell'istanza di 3-SAT può essere eseguita in tempo polinomiale. Supponiamo che esista un'assegnazione T di verità alle variabili di X che soddisfa C. Quindi, T soddisfa c per ogni clausola c e C: mostriamo che tale assegnazione può essere estesa alle nuove variabili di tipo y c introdotte nel definire D c , in modo che tutte le clausole in esso contenute siano soddisfatte (da quanto detto sopra, possiamo supporre che |c| > 3). Poiché c è soddisfatta da T, deve esistere H tale che T soddisfa IH con 0 ^ h ^ |c| — 1: estendiamo T assegnando il valore TRUE a tutte le variabili y? con 0 ^ i ^ h — 2 e il valore FALSE alle rimanenti variabili. In questo modo, siamo sicuri che la clausola di D c contenente Ih è soddisfatta (da Ih stesso), le clausole che la precedono sono soddisfatte grazie al loro terzo letterale e quelle che la seguono lo sono grazie al loro primo letterale. Viceversa, supponiamo che esista un'assegnazione T di verità alle variabili di Z che soddisfi tutte le clausole in D e, per assurdo, che tale assegnazione ristretta alle sole variabili di X non soddisfi almeno una clausola c e C, ovvero che tutti i letterali contenuti in c non siano soddisfatti (di nuovo, ipotizziamo che |c| > 3). Ciò implica che tutte le variabili di tipo y c devono essere vere, perché altrimenti una delle prime |c| — 3 clausole in D c non è soddisfatta, contraddicendo l'ipotesi che T soddisfa tutte le clausole in D. Quindi, x(yf c |_ 4 ) = TRUE, ovvero T(yf c |_ 4 ) = FALSE: poiché abbiamo supposto che anche l| c |-2 e t|c|-i n o n sono soddisfatti, l'ultima clausola in D c non è soddisfatta, contraddicendo nuovamente l'ipotesi che T soddisfa tutte le clausole in D. In conclusione, abbiamo dimostrato che C è soddisfacibile se e solo se D lo è e, quindi, che il problema SAT è trasformabile in tempo polinomiale nel problema 3-SAT: quindi, quest'ultimo è NP-completo. Notiamo che, in modo simile a quanto fatto per 3-SAT, possiamo mostrare la NP-completezza del problema della soddisfacibilità nel caso in cui le clausole contengono esattamente k letterali, per ogni k ^ 3: tale affermazione non si estende però al caso in cui k = 2, in quanto, come abbiamo visto nel Paragrafo 9.1.2, in questo caso il problema diviene risolvibile in tempo polinomiale e, quindi, difficilmente esso è anche NP-completo. La NP-completezza di 3-SAT ha un duplice valore: da un lato esso mostra che la difficoltà computazionale del problema della soddisfacibilità non dipende dalla lunghezza delle clausole (fintanto che queste contengono almeno tre letterali), dall'altro ci consente nel seguito di usare 3-SAT come problema di partenza, il quale, avendo istanze più regolari, è più facile da utilizzare per sviluppare trasformazioni volte a dimostrare risultati di N P-completezza.

Figura 9.3

9.2.2

Un esempio di minimo ricoprimento tramite vertici.

Tecnica di progettazione di componenti

Per dimostrare la NP-completezza del problema del massimo insieme indipendente in un grafo (o meglio della sua versione decisionale), mostriamo prima che il seguente problema, detto minimo ricoprimento tramite vertici è NP-completo: dato un grafo G = (V, E) e un intero k > 0, esiste un sottoinsieme V' di V con |V'| < k, tale che ogni arco del grafo è coperto da V' ovvero, per ogni arco (u, v) € E, u € V' oppure v S V'? Nella Figura 9.3 mostriamo un esempio di ricoprimento tramite 3 vertici del grafo delle conoscenze discusso nel Paragrafo 6.1.1. Notiamo che, in questo caso, un qualunque sottoinsieme di vertici di cardinalità minore di 3, non può essere un ricoprimento: in effetti, due vertici sono necessari per coprire il triangolo formato da V], V2 e V4 e un ulteriore vertice è necessario per coprire l'arco tra V3 e V5. Il problema del minimo ricoprimento tramite vertici ammette dimostrazioni brevi e verificabili in tempo polinomiale: tali dimostrazioni sono i sottoinsiemi dell'insieme dei vertici del grafo che costituiscono un ricoprimento degli archi di cardinalità al più k. Mostriamo ora che 3-SAT è trasformabile in tempo polinomiale nel problema del minimo ricoprimento tramite vertici: a tale scopo, faremo uso di una tecnica più sofisticata di quella vista nel paragrafo precedente, che viene generalmente indicata con il nome di progettazione di componenti. In particolare, la trasformazione opera definendo, per ogni variabile, una componente (gadget) del grafo il cui scopo è quello di modellare l'assegnazione di verità alla variabile e, per ogni clausola, una componente il cui scopo è quello di modellare la soddisfacibilità della clausola. I due insiemi di componenti sono poi collegati tra di loro per garantire che l'assegnazione alle variabili soddisfi tutte le clausole.

Più precisamente, sia C = { c o , . . . , c m _ i } un insieme di m clausole costruite a partire dall'insieme X di variabili booleane { x o , . . . , x n _ i } , tali che |c-L| = 3 per 0 ^ i < invogliamo definire un grafo G e un intero k tale che C è soddisfacibile se e solo se G include un ricoprimento di esattamente k vertici. Per ogni variabile con 0 ^ i < n , G include due vertici v? ero e v[also collegati tra di loro mediante un arco. Queste sono le componenti di verità del grafo, in quanto ogni ricoprimento di G deve necessariamente includere almeno un vertice tra vVero e v-also per 0 ^ i < n : il valore di k sarà scelto in modo tale che ne includa esattamente uno, ovvero quello corrispondente al valore di verità della variabile corrispondente. Per ogni clausola Cj con 0 ^ j < m, G include una cricca di tre vertici v?, v- e v 2 . Queste sono le componenti corrispondenti alla soddisfacibilità delle clausole, in quanto ogni ricoprimento di G deve necessariamente includere almeno due vertici tra v9, v' e v? per 0 ^ j < m: il valore di k sarà scelto in modo tale che ne includa esattamente due, in modo che quello non selezionato corrisponda a un letterale certamente soddisfatto all'interno della clausola corrispondente. Le componenti di verità e quelle di soddisfacibilità sono collegate tra di loro aggiungendo un arco tra i vertici contenuti nelle prime componenti con i corrispondenti vertici contenuti nelle seconde componenti. Più precisamente, per ogni t, j e k con 0 < i < n , 0
Figura 9.4

Un esempio di riduzione da 3-SAT al problema del minimo ricoprimento tramite vertici: le clausole sono {xo, xi, xj}, {xo, xi, xj} e {xo, xi", xj}.

ogni componente di soddisfacibilità, ne include due, abbiamo che V ' è un ricoprimento e che |V'| = n + 2 m = k . Facendo riferimento all'esempio mostrato nella Figura 9.4, supponiamo che T assegni il valore TRUE alla sola variabile xo: in tal caso, V ' include i vertici VGERO, VJALSO e lso . Il primo letterale soddisfatto contenuto nella prima clausola è Xo, che si trova in posizione 0: quindi, V ' include i due vertici Vq e Vq. Analogamente, possiamo mostrare che V' include i vertici v®, v j . v ' e v j c che, quindi, è un ricoprimento del grafo di cardinalità 3 + 6 = 9. Viceversa, supponiamo che V' sia un ricoprimento di G che include esattamente n + 2 m nodi. Ciò implica che V ' deve includere un vertice per ogni componente di verità e due vertici per ogni componente di soddisfacibilità. Definiamo un'assegnazione di verità x tale che t(XÌ) = TRUE se e solo se vVero e V per 0 ^ i < n : chiaramente, T è un'assegnazione di verità corretta (ovvero, non assegna alla stessa variabile due valori di verità diversi). Inoltre, per ogni clausola Cj con 0 ^ j < m, deve esistere h. con 0 ^ h. < 3 tale che vj 1 £ V': l'arco che unisce v-1 al vertice corrispondente contenuto in una componente di verità deve, quindi, essere coperto da quest'ultimo che è incluso in V . Pertanto, l'(h. + l)-esimo letterale in Cj è soddisfatto da T e la clausola e, è anch'essa soddisfatta. Facendo sempre riferimento all'esempio mostrato nella Figura 9.4, supponiamo che V ' includa i vertici V q , V J , V ^ , v{], V q . V j , v j , V^ e V ^ : in tal caso, x assegna il valore FALSE a tutte e tre le variabili booleane. Tale assegnazione soddisfa tutte le clausole di C: ad esempio, della componente corrispondente alla prima clausola V non include il vertice Vq ma della componente corrispondente a X2 include il vertice vip 0 , per cui t(x2) = TRUE e la clausola è soddisfatta. I S O

ALSO

S O

Poiché il grafo G può essere costruito in tempo polinomiale a partire dall'insieme di clausole C, abbiamo che 3-SAT è polinomialmente trasformabile nel problema del minimo ricoprimento tramite vertici e, quindi, che quest'ultimo è NP-completo.

9.2.3

Tecnica di similitudine

A partire dal problema del minimo ricoprimento tramite vertici siamo ora in grado di dimostrare la NP-completezza del seguente: dato un grafo G = (V, E) e un intero k ^ 0, esiste un sottoinsieme V' di V con |V'| > k, tale che V ' è un insieme indipendente ovvero, per ogni arco (u, v) £ E, u 0 V ' oppure v 0 V'? In questo caso, la trasformazione è molto più semplice di quelle viste finora e si basa sulla tecnica della similitudine, che consiste appunto nel mostrare come un problema sia simile a uno già precedentemente dimostrato essere NP-completo. Nel nostro caso, dato un grafo G = (V, E), il concetto di similitudine si manifesta nell'equivalenza tra il fatto che V C V è un insieme indipendente di G e quello che V — V ' è un ricoprimento tramite vertici di G. Infatti, se V' è un insieme indipendente, allora V—V' è un ricoprimento in quanto, se così non fosse, esisterebbe un arco (u, v) £ E tale che u ^ V - V ' e v ^ V - V': quindi, esisterebbe un arco (u, v) £ E tale che u £ V ' e v £ V ' contraddicendo l'ipotesi che V' è un insieme indipendente. Viceversa, se V — V ' è un ricoprimento tramite vertici, allora V ' è un insieme indipendente in quanto, se così non fosse, esisterebbe un arco (u,v) £ E tale che u £ V' e v £ V': quindi, esisterebbe un arco (u, v) £ E tale che u. 0 V — V ' e v 0 V — V' contraddicendo l'ipotesi che V — V ' è un ricoprimento. Ad esempio, nel caso della Figura 9.3, abbiamo che l'insieme formato dai vertici vi, V4 e V5 è un ricoprimento tramite vertici, mentre l'insieme complementare formato dai vertici vo, V2 e V3 è un insieme indipendente. Pertanto, il problema del minimo ricoprimento tramite vertici è trasformabile in quello del massimo insieme indipendente e viceversa. Notiamo che il problema del massimo insieme indipendente ammette dimostrazioni brevi e verificabili in tempo polinomiale, che altro non sono se non i sottoinsiemi di vertici che formano un insieme indipendente. Abbiamo pertanto aggiunto, alla nostra lista di problemi NP-completi, il problema del massimo insieme indipendente.

9.2.4

Tecnica di restrizione

L'ultimo esempio di dimostrazione di NP-completezza che forniamo si basa sulla tecnica più semplice in assoluto, detta della restrizione, che consiste nel mostrare come un problema già noto essere NP-completo sia un caso speciale di un altro problema: da ciò ovviamente deriva la NP-completezza di quest'ultimo. Come esempio, consideriamo il problema del minimo insieme di campionamento, che è definito nel modo seguente: dato un insieme C di sottoinsiemi di un insieme A e

dato un numero intero k > 0, esiste un sottoinsieme A ' di A tale che |A'| ^ k e A ' è u n campionamento di C ovvero, per ogni insieme C É C , c i l A ' / | ? Possiamo restringere questo problema a quello del minimo ricoprimento tramite vertici, limitandoci a considerare istanze in cui ciascun elemento di C contiene esattamente due elementi di A: intuitivamente, A corrisponde all'insieme dei vertici del grafo e C all'insieme degli archi. Poiché il problema del minimo ricoprimento tramite vertici è NP-completo e poiché quello del minimo insieme di campionamento ammette dimostrazioni brevi e verificabili in tempo polinomiale (costituite dal campione A'), abbiamo che anche quest'ultimo problema è NP-completo: d'altra parte, se riuscissimo a progettare un algoritmo polinomiale per questo, potremmo ugualmente risolvere il problema del minimo ricoprimento tramite vertici in tempo polinomiale, applicando tale algoritmo alle sole istanze ristrette.

9.2.5

Come dimostrare risultati di NP-completezza

Il concetto di NP-completezza è stato introdotto alla metà degli anni '70. Da allora, migliaia di problemi computazionali sono stati dimostrati essere NP-completi, di tipologie diverse e provenienti da molte aree applicative. Un punto cruciale nel cercare di dimostrare che un nuovo problema TI è NP-completo consiste nella scelta del problema da cui partire, ovvero il problema NP-completo TI' che deve essere trasformato in IT (notiamo che un tipico errore che si commette inizialmente è quello di pensare che IT deve essere trasformato in Fi' e non viceversa). A tale scopo, nel loro libro Algorithm Design, Jon Kleinberg e Eva Tardos identificano i seguenti sei tipi primitivi di problema, suggerendo per ciascuno uno o più potenziali candidati a svolgere il ruolo del problema computazionale FI'. Problemi di sottoinsiemi massimali. Dato un insieme di oggetti, cerchiamo un suo sottoinsieme di cardinalità massima che soddisfi determinati requisiti: un tipico esempio di problemi siffatti è il problema del massimo insieme indipendente. Problemi di sottoinsiemi minimali. Dato un insieme di oggetti, cerchiamo un suo sottoinsieme di cardinalità minima che soddisfi determinati requisiti: due tipici esempi di problemi siffatti sono il problema del minimo ricoprimento tramite vertici e quello del minimo insieme di campionamento. Problemi di partizionamento. Dato un insieme di oggetti, cerchiamo una sua partizione nel minor numero possibile di sottoinsiemi disgiunti che soddisfino determinati requisiti (in alcuni casi, viene anche richiesto che i sottoinsiemi della partizione siano scelti tra una collezione specificata nell'istanza del problema): un tipico esempio di problemi siffatti è il problema della colorazione di grafi. Problemi di ordinamento. Dato un insieme di oggetti, cerchiamo un suo ordinamento che soddisfi determinati requisiti: tipici esempi di problemi di questo tipo sono

il problema del circuito hamiltoniano e quello del commesso viaggiatore (di cui parleremo nel prossimo paragrafo). Problemi numerici. Dato un insieme di numeri interi, cerchiamo un suo sottoinsieme che soddisfi determinati requisiti: tipici esempi di problemi di questo tipo sono il problema della partizione e quello della bisaccia. Notiamo che la difficoltà di questi problemi risiede principalmente nel dover trattare numeri arbitrariamente grandi: in effetti, i due problemi suddetti, ristretti a istanze in cui i numeri in gioco sono polinomialmente limitati rispetto alla lunghezza dell'istanza, sono risolvibili in tempo polinomiale (Paragrafo 2.7.4). Problemi di soddisfacimento di vincoli. Dato un sistema di vincoli espressi, generalmente, mediante formule booleane o equazioni lineari su uno specifico insieme di variabili, cerchiamo un'assegnazione alle variabili che soddisfi il sistema: un tipico esempio di problemi siffatti è il problema della soddisfacibilità (eventualmente ristretto a istanze con clausole contenenti esattamente tre letterali). Una volta scelto il problema Fi' da cui partire, la progettazione della trasformazione di TV in n è un compito diffìcile tanto quanto quello di progettare un algoritmo polinomiale di risoluzione per FI: in effetti, in Computers and Intractability. A Guide to the Theory of NP-Completeness, Michael Garey e David Johnson suggeriscono di procedere parallelamente nelle due attività, in quanto le difficoltà che si incontrano nella progettazione di un algoritmo possono fornire suggerimenti alla progettazione della trasformazione e viceversa. Sebbene la capacità di dimostrare risultati di NP-completezza sia un'abilità che, una volta acquisita, può risultare poi di facile applicazione, non è certo possibile, come nel caso della capacità di sviluppare algoritmi efficienti, spiegarla in modo formale. Ciò nondimeno, Steven Skiena, nelle sue dispense di un corso su algoritmi, fornisce i seguenti suggerimenti di cui possiamo tener conto quando ci accingiamo a voler dimostrare che un dato problema è NP-completo: • rendiamo TV il più semplice possibile (ad esempio, conviene usare 3-SAT invece di S A T ) ; • rendiamo TI il più difficile possibile, eventualmente aggiungendo (temporaneamente) vincoli ulteriori; • identifichiamo in Fi le soluzioni canoniche e introduciamo qualche forma di penalizzazione nei confronti di una qualunque soluzione che non sia canonica (ad esempio, nel caso del problema del minimo ricoprimento tramite vertici, una soluzione canonica è formata da un vertice per ogni componente di verità e due vertici per ogni componente di soddisfacibilità); • prima di produrre gadget (nel caso della tecnica della progettazione di componenti), ragioniamo ad alto livello chiedendoci cosa e come intendiamo fare per forzare a scegliere soluzioni canoniche.

Per quanto utili, questi suggerimenti sono abbastanza vaghi: nella realtà, non esiste altro modo di imparare a progettare trasformazioni tra problemi computazionali se non facendolo. Per questo motivo, in questo capitolo abbiamo preferito fornire pochi esempi di tali trasformazioni, lasciando al lettore il compito di cimentarsi con altri problemi, presi magari dalla lista di problemi NP-completi presenti nel libro di Garey e Johnson.

9.3

Algoritmi di approssimazione

Dimostrare che un problema è NP-completo significa rinunciare a progettare per esso un algoritmo polinomiale di risoluzione (a meno che non crediamo che P sia uguale a NP). A questo punto, però, ci chiediamo come dobbiamo comportarci: dopo tutto, il problema deve essere risolto. A questo interrogativo possiamo rispondere in diversi modi. Il primo e il più semplice consiste nell'ignorare la complessità temporale intrinseca del problema, sviluppare comunque un algoritmo di risoluzione e sperare che nella pratica, ovvero con istanze provenienti dal mondo reale, il tempo di risoluzione sia significativamente minore di quello previsto: dopo tutto, l'analisi nel caso pessimo, in quanto tale, non ci dice come si comporterà il nostro algoritmo nel caso di specifiche istanze. Un secondo approccio, in linea con quello precedente ma matematicamente più fondato, consiste nell'analizzare l'algoritmo da noi progettato nel caso medio rispetto a una specifica distribuzione di probabilità: questo è quanto abbiamo fatto nel caso dell'algoritmo di ordinamento per distribuzione (Paragrafo 2.5.4). Vi sono due tipi di problematiche che sorgono quando vogliamo perseguire tale approccio. La prima consiste nel fatto che un'analisi probabilistica del comportamento dell'algoritmo è quasi sempre difficile e richiede strumenti di calcolo delle probabilità talvolta molto sofisticati. La seconda e, probabilmente, più grave questione è che l'analisi probabilistica richiede la conoscenza della distribuzione di probabilità con cui le istanze si presentano nel mondo reale: purtroppo, quasi mai conosciamo tale distribuzione e, pertanto, siamo costretti a ipotizzare che essa sia una di quelle a noi più familiari, come la distribuzione uniforme. Un terzo approccio si applica al caso di problemi di ottimizzazione, per i quali a ogni soluzione è associata una misura e il cui scopo consiste nel trovare una soluzione di misura ottimale: in tal caso, possiamo rinunciare alla ricerca di soluzioni ottime e accontentarci di progettare algoritmi efficienti che producano si soluzioni peggiori, ma non troppo. In particolare, diremo che A è un algoritmo di r-approssimazione per il problema di ottimizzazione Fi se, per ogni istanza x di FI, abbiamo che A con x in ingresso restituisce una soluzione di x la cui misura è al più r volte quella di una soluzione ottima (nel caso la misura sia un costo) oppure almeno i-esimo di quella di una soluzione ottima (nel caso la misura sia un profitto), dove r è una costante reale strettamente maggiore di 1. Per chiarire meglio tale concetto, consideriamo il problema del minimo ricoprimento tramite vertici, che nella sua versione di ottimizzazione consiste nel trovare un sottoin-

«

sieme dei vertici di un grafo di cardinalità minima che copra tutti gli archi del grafo stesso. Il Codice 9.2 realizza un algoritmo di approssimazione per tale problema basato sul paradigma dell'algoritmo goloso (abbiamo già detto che nel caso degli algoritmi di approssimazione, il paradigma dell'algoritmo goloso risulta spesso essere efficace). In particolare, dopo aver inizializzato la soluzione ponendola uguale all'insieme vuoto (righe 3 e 4), il codice esamina uno dopo l'altro tutti gli archi del grafo (righe 5-11): ogni qualvolta ne trova uno i cui due estremi non sono stati selezionati (riga 7), include entrambi gli estremi nella soluzione (righe 8 e 9). La complessità temporale del Codice 9.2 è 0 ( n 2 ) , in quanto ogni iterazione dei due cicli annidati uno dentro l'altro richiede un numero costante di operazioni. Inoltre, la soluzione prodotta dall'algoritmo è un ricoprimento tramite vertici, poiché ogni arco viene coperto con due vertici se, al momento in cui viene esaminato, questi sono entrambi non inclusi nella soluzione e con almeno un vertice in caso contrario. D'altra parte, non possiamo garantire che tale soluzione sia di cardinalità minima: considerando il grafo mostrato nella Figura 9.3, la soluzione prodotta dall'algoritmo include tutti e sei i vertici mentre quella di cardinalità minima ne ha solamente tre. Possiamo però mostrare che la soluzione calcolata dal Codice 9.2 include un numero di vertici che è sempre minore oppure uguale al doppio della cardinalità di una soluzione ottima. A tale scopo, dato un grafo G, notiamo che il sottografo indotto dalla soluzione S calcolata dall'algoritmo con G in ingresso, è formato da ^ archi a due a due disgiunti, ovvero senza estremi in comune. Chiaramente, un qualunque ricoprimento di tale sottografo (e quindi di G) deve includere almeno ^ vertici: pertanto, |S| è minore oppure uguale al doppio della cardinalità di un qualunque ricoprimento tramite vertici di G e, quindi, della cardinalità minima. ALVIE:

minimo ricoprimento tramite vertici Osserva, sperimenta e verifica VertexCover

9.4

Opus libri: il problema del commesso viaggiatore

Concludiamo questo capitolo e il libro con un'ultima opera algoritmica, relativa a uno dei problemi di ottimizzazione più analizzati (in tutte le sue varianti) nel campo dell'informatica e della ricerca operativa, ovvero il problema del commesso viaggiatore.

RicoprimentoVertici( A ): (pre: A è la matrice di adiacenza di un grafo di n nodi) FOR (i = 0; i < n; i = i + 1) presoti] = FALSE; FOR (i = 0; i < n; i = i + 1) FOR (j = 0; j < n; j = j + 1) {

IF (A[i][j] == 1 && ! preso [i] && !preso[j]) { presoti] = TRUE; preso[j] = TRUE;

> } RETURN preso; Codice 9.2

Algoritmo per il calcolo di un ricoprimento tramite vertici.

Dato un insieme di città e specificato, per ogni coppia di città, la distanza chilometrica per andare dall'una all'altra o viceversa, un commesso viaggiatore si chiede quale sia il modo più breve per visitare tutte le città una e una sola volta, tornando al termine del giro alla città di partenza. Consideriamo, ad esempio, la seguente istanza del problema in cui 9 città olandesi sono analizzate e in cui le distanze chilometriche sono tratte da una nota guida turistica internazionale:

Amsterdam Breda Dordrecht Eindhoven Haarlem L'Aia Maastricht Rotterdam Utrecht

A 0

B 101 0

D 98 30 0

E 121 57 92 0

H 20 121 94 136 0

L 55 72 45 134 51 0

M 213 146 181 86 228 223 0

R 73 51 24 113 70 21 202 0

U 37 73 61 88 54 62 180 57 0

Se il commesso viaggiatore decide di percorrere le città secondo il loro ordine alfabetico, allora percorre un numero di chilometri pari a 101 + 30 + 92 + 136 + 51 + 223 + 202 + 57 + 37 = 929 Supponiamo, invece, che decida di percorrerle nel seguente ordine: Amsterdam, Haarlem, L'Aia, Rotterdam, Dordrecht, Breda, Maastricht, Eindhoven e Utrecht. In tal caso, il commesso viaggiatore percorre un numero di chilometri pari a 20 + 51 + 21 + 24 + 30 + 146 + 86 + 88 + 37 = 503

Mediante una ricerca esaustiva di tutte le possibili 9! = 362880 permutazioni delle nove città, possiamo verificare che quest'ultima è la soluzione migliore possibile. Sfortunatamente, il commesso viaggiatore non ha altra scelta che applicare un algoritmo esaustivo per trovare la soluzione al suo problema, in quanto la sua versione decisionale è un problema NP-completo. Più precisamente, consideriamo il seguente problema di decisione: dati un grafo completo G = (V, E), una funzione p che associa a ogni arco del grafo un numero intero non negativo e un numero intero k ^ 0, esiste un tour del commesso viaggiatore di peso non superiore a k, ovvero un ciclo hamiltoniano in G (Paragrafo 6.1.1) la somma dei cui archi è minore oppure uguale a k? Per dimostrare che tale problema è NP-completo, consideriamo il problema del circuito hamiltoniano che consiste nel decidere se un grafo qualsiasi include un ciclo hamiltoniano. Utilizzando la tecnica della progettazione di componenti possiamo dimostrare che tale problema è NP-completo. Mostriamo ora che la ricerca di un ciclo hamiltoniano è trasformabile in tempo polinomiale nella versione decisionale del problema del commesso viaggiatore. Dato un grafo G = (V, E), definiamo un grafo completo G' = (V, E') e una funzione p tale che, per ogni arco e in E', p(e) = 1 se e G E, altrimenti p(e) = 2. Scegliendo k = |V|, abbiamo che se esiste un ciclo hamiltoniano in G, allora esiste un tour in G' il cui costo è uguale a k. Viceversa, se non esiste un ciclo hamiltoniano in G, allora ogni tour in G' deve includere almeno un arco il cui peso sia pari a 2, per cui ogni tour ha un costo almeno pari a k + 1. In conclusione, il problema del commesso viaggiatore (nella sua forma decisionale) è NP-completo. Sfortunatamente, possiamo mostrare che il problema di ottimizzazione non ammette neanche un algoritmo efficiente di approssimazione. A tale scopo, consideriamo nuovamente il problema del circuito hamiltoniano e, facendo uso della tecnica detta del gap, dimostriamo che se il problema del commesso viaggiatore ammette un algoritmo efficiente di approssimazione, allora il problema del circuito hamiltoniano è risolvibile in tempo polinomiale. Sia r > 1 una costante e sia A un algoritmo polinomiale di r-approssimazione per il problema del commesso viaggiatore. Dato un grafo G = (V, E), definiamo un grafo completo G' = (V, E') e una funzione p tale che, per ogni arco e in E', p(e) = 1 se e e E, altrimenti p(e) = 1 + s|V| dove s > r — 1. Notiamo che G' ammette un tour del commesso viaggiatore di costo pari a |V| se e solo se G include un circuito hamiltoniano: infatti, un tale tour deve necessariamente usare archi di peso pari a 1, ovvero arphi contenuti in E. Sia T il tour del commesso viaggiatore che viene restituito da A con G ' in ingresso. Dimostriamo che T può essere usato per decidere se G ammette un ciclo hamiltoniano, distinguendo i seguenti due casi. 1. Il costo di T è uguale a |V|, per cui T è un tour ottimo. Quindi, G ammette un ciclo hamiltoniano.

CommessoViaggiatoreC P ): (pre: ? è la matrice di adiacenza e dei pesi di un grafo G completo di n nodi) mst = Jarnik-Prim( P ); cicloEuleriano = Euler( mst ); FOR (i = 0; i < n; i = i +1) visitatoti] = -1; posizione = 0; FOR ( i = 0 ; i < 2 x n - 1; i = i +1) { IF (visitato[ cicloEuleriano[i] ] < 0) { visitato[ cicloEuleriano[i] ] = posizione; posizione = posizione + 1;

> > RETURN

Codice 9.3

v i s i t a t o ;

Algoritmo per il calcolo di un tour approssimato del commesso viaggiatore.

2. Il costo di T è maggiore di |V|, per cui il suo costo deve essere almeno pari a |V| - 1 + 1 + s|V| = (1 + s)|V] > r|V[. In questo caso, il tour ottimo non può avere costo pari a |V|, in quanto altrimenti il costo di T è maggiore di r volte il costo ottimo, contraddicendo il fatto che A è un algoritmo di r-approssimazione: quindi, non esiste un ciclo hamiltoniano in G. In conclusione, applicando l'algoritmo A al grafo G ' e verificando se la soluzione restituita da A ha un costo pari oppure maggiore al numero dei vertici, possiamo decidere in tempo polinomiale se G ammette un circuito hamiltoniano, contraddicendo il fatto che il problema del circuito hamiltoniano è NP-completo.

9.4.1

Problema del commesso viaggiatore su istanze metriche

Sebbene il problema del commesso viaggiatore non sia, in generale, risolvibile in modo approssimato mediante un algoritmo polinomiale, possiamo mostrare che tale problema, ristretto al caso in cui la funzione che specifica la distanza tra due città soddisfi la disuguaglianza triangolare, ammette un algoritmo di 2-approssimazione. Un'istanza del problema del commesso viaggiatore soddisfa la disuguaglianza triangolare se, per ogni tripla di vertici i, j e k, p(i, j) ^ p(i, k) + p(k, j): intuitivamente, ciò vuol dire che andare in modo diretto da una città i a una città j non può essere più costoso che andare da i a j passando prima per un'altra città k. L'esempio delle città olandesi visto in precedenza soddisfa la disuguaglianza triangolare, anche se tale disuguaglianza non sempre è soddisfatta quando si tratta di distanze stradali.

La disuguaglianza triangolare è invece sempre soddisfatta se i vertici del grafo rappresentano punti del piano euclideo e le distanze tra due vertici corrispondono alle loro distanze nel piano, in quanto in ogni triangolo la lunghezza di un Iato è sempre minore della somma delle lunghezze degli altri due lati. Inoltre, la disuguaglianza è soddisfatta nel caso in cui il grafo completo G sia ottenuto nel modo seguente, a partire da un grafo G ' connesso non necessariamente completo: G ha gli stessi vertici di G ' e la distanza tra due suoi vertici è uguale alla lunghezza del cammino minimo tra i corrispondenti vertici di G'. Per questo motivo, la risoluzione del problema del commesso viaggiatore, ristretto al caso di istanze che soddisfano la disuguaglianza triangolare, è un problema di per sé interessante che sorge abbastanza naturalmente in diverse aree applicative. La versione decisionale di tale problema è NP-completo, in quanto la trasformazione che abbiamo mostrato in precedenza a partire dal problema del circuito hamiltoniano genera istanze che soddisfano la disuguaglianza triangolare: se i pesi degli archi sono solo 1 e 2, ovviamente tale disuguaglianza è sempre soddisfatta. Mostriamo ora un algoritmo polinomiale di 2-approssimazione per il problema del commesso viaggiatore, ristretto al caso di istanze che soddisfano la disuguaglianza triangolare. L'idea alla base dell'algoritmo è che la somma dei pesi degli archi di un minimo albero ricoprente R di un grafo completo G costituisce un limite inferiore al costo di un tour ottimo. Infatti, cancellando un arco di un qualsiasi tour T, otteniamo un cammino hamiltoniano e, quindi, un albero ricoprente: la somma dei pesi degli archi di questo cammino deve essere, per definizione, non inferiore a quella dei pesi degli archi di R. Quindi, il costo di T (che include anche il peso dell'arco cancellato) è certamente non inferiore alla somma dei pesi degli archi di R. L'algoritmo (realizzato nel Codice 9.3) costruisce un minimo albero ricoprente di G (riga 3) e, in modo analogo a quanto fatto nel caso del problema del minimo antenato comune (Paragrafo 4.2.1), visita tale albero in profondità creando un ciclo euleriano (riga 4). Ricordiamo che, in tale ciclo, ogni vertice dell'albero può essere visitato più di una volta, ma che ogni arco dell'albero viene percorso esattamente due volte: una andando dal padre verso il figlio e una tornando dal figlio al padre. Pertanto, il ciclo euleriano è formato da 2 n — 1 elementi, di cui il primo e l'ultimo coincidono, come mostrato nella Figura 9.5. A questo punto, l'algoritmo percorre l'intero ciclo euleriano (righe 8—13): ogni qualvolta incontra un vertice non ancora visitato (riga 9), lo inserisce nel tour del commesso viaggiatore nella posizione attuale (riga 10) e aggiorna quest'ultima (riga 11). In altre parole, il codice costruisce il tour del commesso viaggiatore viaggiando attraverso gli archi che uniscono le prime occorrenze di ciascun nodo nel ciclo euleriano. L'algoritmo restituisce, infine, l'array delle posizioni dei vertici all'interno del tour (riga 14), supponendo implicitamente che il vertice in ultima posizione (ovvero, posizione n — 1) deve essere connesso a quello in prima posizione (ovvero, posizione 0).

(L)

r ) ( H )

( R J ( H

r i ) ( A )

J

Ì m)

Figura 9.5

)

(

u

)

C

d

)

)

(

A

C b ) ( U

i

|

) (M)

Un minimo albero ricoprente del grafo delle città olandesi, il corrispondente ciclo euleriano e il tour del commesso viaggiatore.

Poiché il calcolo del minimo albero ricoprente e del corrispondente ciclo euleriano possono essere realizzati in 0 ( n 2 logn) e poiché il resto del codice richiede O(n) tempo, abbiamo che l'algoritmo appena descritto è polinomiale. Per dimostrare che è anche un algoritmo di 2-approssimazione, notiamo anzitutto che la somma dei pesi degli archi inclusi nel ciclo euleriano è al più due volte la somma dei pesi degli archi presenti nel minimo albero ricoprente. Inoltre, in base alla disuguaglianza triangolare, i salti che vengono eseguiti per costruire il tour non possono essere più costosi della parte di ciclo euleriano su cui essi passano sopra: quindi, il costo complessivo del tour è al più pari alla somma dei pesi degli archi inclusi nel ciclo euleriano, la quale a sua volta è al più due volte la somma dei pesi degli archi presenti nel minimo albero ricoprente che, come abbiamo osservato in precedenza, non è superiore al costo del tour ottimale. Più precisamente, sia. io, i-i , . . . , i^—i la sequenza dei nodi inclusi nel ciclo euleriano, dove m = 2rt — 1. Inoltre, siano jo> ) i » • • • > ) n - i ' e posizioni delle prime occorrenze degli

n vertici di G all'interno del ciclo euleriano: quindi, ij 0 = 0, ij h / ij k per 0 ^ h. < k < n e ij n _! ^ ij 0 . Infine, poniamo j n = m — 1. Il tour del commesso viaggiatore costruito dal Codice 9.3 include gli archi (ij h >ij h + 1 ) per 0 ^ h < n . In base alla disuguaglianza triangolare, abbiamo che PÌijh'ijK+i) < P i i j h ' ^ h + !) +P( i )K + l , i j h + 2) + • • • + p ( i j h + 1 - l , i j h + , ) per 0 ^ h. < n : quindi, il costo del tour calcolato dall'algoritmo è limitato superiormente dalla somma dei pesi degli archi inclusi nel ciclo euleriano. In conclusione, tale tour ha un costo pari al più a due volte il costo minimo. Per concludere, osserviamo che l'algoritmo di approssimazione realizzato dal Codice 9.3 non è il migliore possibile. In effetti, con un opportuno accorgimento nello scegliere gli archi del minimo albero ricoprente da duplicare, possiamo modificare tale algoritmo ottenendone uno di 1,5-approssimazione. Inoltre, nel caso di istanze formate da punti sul piano euclideo, possiamo dimostrare che, per ogni r > 1, esiste un algoritmo polinomiale di r-approssimazione: in altre parole, il problema del commesso viaggiatore sul piano può essere approssimato tanto bene quanto vogliamo (ovviamente al prezzo di una complessità temporale che, pur mantenendosi polinomiale, cresce al diminuire di r). ALVIE:

problema del commesso viaggiatore Osserva, sperimenta e verifica TravelingSalesman

9.4.2

Paradigma della ricerca locale

Un algoritmo per la risoluzione di un problema di ottimizzazione basato sul paradigma della ricerca locale opera nel modo seguente: a partire da una soluzione iniziale del problema, esplora un insieme di soluzioni "vicine" a quella corrente e si sposta in una soluzione che è migliore di quella corrente, fino a quando non giunge a una che non ha nessuna soluzione vicina migliore. Pertanto, il comportamento di un tale algoritmo dipende dalla nozione di vicinato di una soluzione (solitamente generato applicando operazioni di cambiamento locale alla soluzione corrente), dalla soluzione iniziale (che può essere calcolata mediante un altro algoritmo) e dalla strategia di selezione delle soluzioni (ad esempio, scegliendo la prima soluzione vicina migliore di quella corrente oppure selezionando la migliore tra tutte quelle vicine alla corrente). Non esistono regole generali per decidere quali siano le regole di comportamento migliori: per questo, ci limitiamo in questo paragrafo finale a descrivere due algoritmi

basati sul paradigma della ricerca locale per la risoluzione (non ottima) del problema del commesso viaggiatore. Notiamo sin d'ora che non siamo praticamente in grado di formulare nessuna affermazione (non banale) relativamente alle prestazioni di questi algoritmi né in termini di complessità temporale né in termini di qualità della soluzione ottenuta. Tuttavia, questo tipo di strategie (dette anche euristiche) risultano nella pratica estremamente valide e, per questo, molto utilizzate. Entrambi gli algoritmi che descriviamo fanno riferimento a operazioni locali di cambiamento: essi tuttavia differiscono tra di loro per quello che riguarda la lunghezza massima della sequenza di tali operazioni. In particolare, i due algoritmi modificano la soluzione corrente selezionando un numero fissato di archi e sostituendoli con un altro insieme di archi (della stessa cardinalità) in modo da ottenere un nuovo tour. Il primo algoritmo, detto 2-opt, opera nel modo seguente: dato un tour T del commesso viaggiatore, il suo vicinato è costituito da tutti i tour che possono essere ottenuti cancellando due archi (x,y) e (u, v) di T e sostituendoli con due nuovi archi (x, u) e (y, v) in modo da ottenere un tour differente T' (notiamo che questo equivale a invertire la percorrenza di una parte del tour T, come mostrato nella Figura 9.6). Se il nuovo tour T' ha un costo minore di quello di T, allora T' diviene la soluzione corrente, altrimenti l'algoritmo procede con una diversa coppia di archi: il procedimento ha termine nel momento in cui giungiamo a un tour che non può essere migliorato. Il Codice 9.4 realizza l'algoritmo 2-opt. Dopo aver inizializzato il tour iniziale e il relativo costo, visitando i vertici nell'ordine in cui appaiono nel grafo (righe 3—5), il codice esamina tutte le coppie di archi (i, i + 1) e (j,j + I) con 0 < i < } — 1 < n — 1 (righe 6-26) e per ognuna di esse genera il nuovo tour operando la sostituzione precedentemente descritta (righe 9-15). Quindi, il codice calcola il costo del nuovo tour (righe 16—19): se tale costo è minore del costo precedente, allora il tour corrente viene

2-0pt( P ): {pre: ? è la matrice di adiacenza e dei pesi di un grafo G completo di n nodi) costo = 0; FOR (i = 0; i < N; i = i +1) { tour[i] = i; costo = costo + P[i] [(i+1) '/, n] ; } FOR (i = 0; i < N; i = i +1) { FOR (j = i+2; j < n-1; j = j + 1) { FOR (h = 0; h <= i; h = h +1) nuovo[h] = tour[h]; nuovo[i+l] = tour[j]; FOR (H = 1; h < j-i; h = h +1) nuovo[i+1+h] = tour[j-h]; nuovo[j+l] = tour[j+l] ; FOR (h = J+2; H < n; h = h +1) nuovo[h] = tour[h]; nuovoCosto = 0; FOR (h = 0; h < n; h = h +1) { nuovoCosto = nuovoCosto + P[nuovo[h]][nuovo[(h+1) '/, n]];

> IF (nuovoCosto < costo) { { costo = nuovoCosto; i = 0; } FOR (h = 0; h < n; h = h+1) tour[h] = nuovoTour[h];

> > > RETURN

Codice 9.4

tour;

Algoritmo 2-opt.

aggiornato e il ciclo f o r più esterno viene fatto ripartire dall'inizio (righe 21 e 23). Se non troviamo nessun tour migliore di quello attuale, allora il codice restituisce il tour attuale come soluzione del problema (riga 27). Poiché, ogni qualvolta viene trovato un tour di costo minore, tale costo diminuisce almeno di un'unità, abbiamo che il numero totale di iterazioni del ciclo f o r più esterno è limitato dal costo del tour iniziale: pertanto, il Codice 9.4 termina in tempo 0 ( n 3 C ) dove C indica il costo del tour iniziale. Il secondo algoritmo di risoluzione del problema del commesso viaggiatore basato sul paradigma della ricerca locale è detto 3-opt, in quanto opera in modo analogo a 2opt, ma considera come vicinato di un tour T tutti i tour che possono essere ottenuti scambiando tre archi di T.

Figura 9.7

L'operazione di modifica di un tour realizzata dall'algoritmo 3-opt.

In particolare, se lo, i i , . . . , i-n-i è il tour corrente, l'algoritmo 3-opt sceglie tre indici io, ji e Ì2 con jo < - 1 < Ì2 - 2 e sostituisce i tre archi ( i j 0 , i j 0 + i), ( i j 1 , i j l + 1 ) e ( i j 2 , i j 2 + i ) con gli archi ( i j o , i j | + i), ( i h , i j o + 1 ) e ( i j p i ^ + i ) (notiamo che in questo caso non abbiamo bisogno di invertire una parte del tour corrente, come mostrato nella Figura 9.7). Possiamo verificare sperimentalmente che 3-opt ha delle prestazioni migliori di 2-opt per quello che riguarda la qualità della soluzione, ma richiede un tempo di calcolo superiore. Sebbene, in linea di principio, possiamo pensare di generalizzare i due algoritmi appena esposti definendo una strategia k-opt per qualunque k ^ 2, il miglioramento che si ottiene nella qualità della soluzione calcolata nel passare da 3-opt a 4-opt non sembra giustificare il significativo peggioramento delle prestazioni in termini di tempo di esecuzione. ALVIE:

algoritmo 2-opt Osserva, sperimenta e verifica TwoOpt

Gli algoritmi 2-opt e 3-opt risultano efficaci nella pratica, ma possono avere prestazioni molto scarse nel caso pessimo (anche in dipendenza della scelta del tour iniziale): in effetti, non conosciamo alcun limite superiore all'approssimazione raggiunta dalla soluzione calcolata da questi algoritmi nel caso generale.

Ciò nonostante, il fatto che in situazioni reali i due algoritmi si comportino relativamente bene fa sì che essi, insieme ad altre euristiche basate sul paradigma della ricerca locale, siano diffusamente utilizzati. RIEPILOGO In questo capitolo abbiamo definito le classi P f N P f abbiamo introdotto il concetto di problema NP-completo. Abbiamo quindi mostrato la NP-completezza di diversi problemi computazionali, indicando alcune linee guida su come sia possibile dimostrare un risultato di NP -completezza. Inoltre, abbiamo introdotto il concetto di algoritmo polinomiale di approssimazione, fornendo un tale algoritmo per ilproblema del ricoprimento tramite vertici e per quello del commesso viaggiatore ristretto a istanze metriche. Infine, abbiamo dimostrato che quest'ultimo problema non ammette algoritmi di approssimazione nel caso generale, ma viene solitamente risolto mediante euristiche basate sul paradigma della ricerca beale, come l'algoritmo 2-opt e quello 3-opt. ESERCIZI 1. Facendo riferimento alla rappresentazione mediante liste di adiacenza e utilizzando una variante della procedura di visita in ampiezza di un grafo vista nel Paragrafo 7.4.1, mostrate che il problema di decidere se un grafo è colorabile con due colori è risolvibile in tempo 0 ( n + m), dove n e m indicano, rispettivamente, il numero di nodi e il numero di archi del grafo. 2. Osservando che, date due formule booleane cp e cp' che non contengono la variabile booleana x, ( p V i p ' è soddisfacibile se e solo se (cp V x) A (cp' V x), mostrate che una formula booleana t^ può essere trasformata in tempo polinomiale in una formula booleana ' in forma normale congiuntiva, tale che tj> è soddisfacibile se e solo se è soddisfacibile. 3. Mostrate che il problema di decidere se, dato un insieme di clausole ciascuna in forma congiuntiva, una di esse è soddisfacibile, può essere risolto in tempo lineare. 4. Sia FI un problema di ottimizzazione tale che, per ogni sua istanza x di dimensione n , la misura della soluzione ottima è limitata da 2 n . Utilizzando la tecnica della ricerca binaria, dimostrate che se il problema di decisione associato a il è in P, allora Fi è risolvibile in tempo polinomiale. 5. Mostrate mediante la tecnica di progettazione delle componenti che il seguente problema è NP-completo: dato un grafo G = (V, E), esiste una colorazione dei vertici in V mediante tre colori?

6. Dato un grafo G, sia G c = (V, E c ) il grafo complementare di G, tale che (u, v) e E c se e solo se (u, v) 0 E. Facendo uso di tale nozione, mostrate per similitudine che il seguente problema è NP-completo: dato un grafo G = (V, E) e un intero k ^ 0, esiste un sottoinsieme V' di V con |V'| > k, tale che V' induce un grafo completo in G ovvero, per ogni u , v S V', (u, v) S E? 7. Considerate una variante del Codice 9.2 in cui, ogni qualvolta esaminiamo un arco i cui estremi non sono inclusi nella soluzione, decidiamo di inserire nella soluzione uno solo dei due estremi (scelto a piacere). Mostrate che non è un algoritmo di approssimazione per il problema del minimo ricoprimento tramite vertici. 8. Considerate una variante del Codice 9.3 in cui, dopo aver calcolato il minimo albero ricoprente T, determiniamo l'insieme di peso minimo M formato da archi a due a due disgiunti i cui estremi sono vertici di grado dispari in T (nel caso mostrato nella Figura 9.5, tale insieme è formato dal solo arco tra Maastricht e Utrecht). Aggiungiamo gli archi di M a T e calcoliamo un ciclo euleriano per questo nuovo grafo: possiamo fare ciò partendo da un nodo i qualsiasi e attraversando gli archi senza mai passare due volte per lo stesso arco. A partire da questo ciclo euleriano, l'algoritmo procede come il Codice 9.3. Mostrate che tale algoritmo è un algoritmo polinomiale di 1,5-approssimazione per il problema del commesso viaggiatore. 9. Scrivete il codice che implementa l'algoritmo 3-opt.

Appendice A

Notazioni

Notazione R x% y W M 1*1 0(f(n)) 0(f(n)) o(f(n)) lo

gbQ Ioga n! (B 2_i = a*i HiSS *i aAb aVb a xe A x^ A |A| AUB AnB A- B

Significato L'insieme dei numeri reali Il resto della divisione intera di x per y Il più grande numero intero n ^ x Il più piccolo numero intero n ^ x Il valore assoluto di x oppure la dimensione di x L'insieme di funzioni g tali che, per ogni costante c > 0, esiste una costante no > 0 per cui vale g(n) ^ cf(n), per ogni n > no L'insieme di funzioni g tali che, per ogni costante c > 0, esistono una costante no > 0 e infiniti valori di n > no per cui vale g(n) ^ cf(n) L'insieme di funzioni g tali che linin^,*, = 0 Il logaritmo in base b di a, ovvero il numero x tale che b* = a log 2 a Il fattoriale n x ( n — 1 ) x (n — 2) x • • • x 2 x 1 per n > 0 Il coefficiente binomiale, ovvero k , ( i ^ k ) i La somma x a + x Q + i + x Q+ 2 + • • • + Xb-i + (per convenzione, tale somma è pari a 0 se b < a) La somma di tutti i valori Xi per cui i appartiene all'insieme S La congiunzione dei due valori booleani a e b, che è vera se e solo se entrambi a e b sono veri La disgiunzione dei due valori booleani a e b, che è vera se e solo se almeno uno tra a e b è vero La negazione del valore booleano a, che è vera se e solo se a non è vero L'elemento x appartiene all'insieme A L'elemento x non appartiene all'insieme A La cardinalità di A, ovvero il numero di elementi contenuti in A L'unione dei due insiemi A e B, ovvero {x : x e A A x 6 B} L'intersezione dei due insiemi A e B, ovvero {x : x e A V x e B} La differenza dei due insiemi A e B, ovvero {x : x e A A x ^ B}

Appendice B

Teorema delle ricorrenze

Se f(n) è una funzione e a, (3 e no sono tre costanti tali che allora l'equazione di ricorrenza Tinl = / 0 ( 1 ) 1 1 \ aT(n/P)+f(n)

1, |3 > 1 e no > 0,

se n ^ no altrimenti

f K

)

'

(dove n/(3 va interpretato come | n / P J o [n/|3~|) ha le seguenti soluzioni per ogni n: 1. T(n) = 0 ( f ( n ) ) se esiste una costante y < 1 tale che a f ( n / ( 3 ) = y f(n); 2. T(n) = 0 ( f ( n ) log p n) se a f ( n / P ) = f(n); 3. T(n) = 0(n'° 6 P ") se esiste una costante y' > 1 tale a f ( n / | 3 ) = y' f(n). Per la dimostrazione dell'enunciato, usiamo l'approccio suggerito da Jeff Erickson, ipotizzando per semplicità che no = 1 e applicando il metodo descritto nel Paragrafo 2.5.5, in modo da calcolare la forma chiusa di T(n) per l'equazione (B.l): il primo livello di ricorsione contribuisce con f(n), il secondo con af(n/(3), il terzo con a 2 f ( n / | 3 2 ) e così via, fino all'ultimo livello dove abbiamo al più a h f ( n / | 3 h ) (in quanto alcune chiamate ricorsive modellate dalla ricorrenza potrebbero essere terminate prima), ottenendo

T(n, , f(n)

+

af ( £ )

+

...

+ B tf

( £ )

+

...

+

«H f

=

£

aif

^

2)

Osserviamo che il valore di h. è tale che n / | 3 H = no = 1, implicando così che h. = O(logpn), di cui teniamo conto nel valutare l'equazione (B.2) nei tre casi previsti dal teorema.

Appendice B - Teorema delle ricorrenze

Nel primo caso, abbiamo che af(n/(3) = y f ( n ) , dove y < 1. Una semplice induzione su i ^ 0 mostra che o c l f ( n / = y 1 ^ ^ ) - Infatti, il caso base (0 ^ i ^ 1) è immediato. Nel caso induttivo, osserviamo che a l + 1 f ( n / | 3 l + 1 ) può essere scritto come

(*f ((£)•/p))-»' (Yf U))( a i f (£)) dove abbiamo usato la proprietà che a f ( x / 3 ) = yf(x) nella prima uguaglianza e l'ipotesi induttiva nell'ultima. Ne deriva che possiamo scrivere l'equazione (B.2) come T(n) ^ L t 0 y f ( n ) = f f n l l t o Y 1 = 0 ( f ( n ) ) i n q u a n t o Z t o T ' = 0 ( 1 ) poichéy < 1. Nel secondo caso abbiamo ocf(n/|3) = f ( n ) e possiamo dimostrare per induzione, con dei passaggi analoghi a quelli del primo caso, che o^ffn/P 1 -) = f ( n ) , per cui l'equazione (B.2) diventa T(n) s$ L i U f ( n ) = ( h + Uff™) = 0 ( f ( n ) log p n ) . Nel terzo caso, analogamente agli altri, vale a l f ( n / | 3 l ) = ( y / ) l f ( n ) : l'equazione (B.2) diventa T(n) ^ L Ì U i V M n ) = f ( n ) Z t o W f = 0 ( ( V ) h f ( n ) ) , in quanto ^ ì ^ o i V ) 1 — 0 ( ( y ' ) h ) poiché y' > 1. Utilizzando la proprietà induttiva su i = h. = O(logp a), ovvero che ( y ' ) h f ( r i ) = a H f ( n / | 3 h ) , possiamo derivare che T(n) = 0 ( a h f ( n / ( 3 h ) ) = 0 ( a H f ( l ) ) = O ( c x l o ^ n ) = o ( 2 l o 6 a l o s n / l o & e ) = O(n l o B0 a ), concludendo la dimostrazione del teorema.

Indice analitico 1-bilanciato, 165-168 2-3-albero, 177 2-opt, 3 4 5 - 3 4 8 3-opt, 3 4 6 - 3 4 9 abbinamento, 9 0 - 9 4 , 206 accesso diretto, 19, 23, 24, 26, 80, 83, 91,92 accesso sequenziale, 23, 25, 80, 83 accoppiamento perfetto, 206 aciclico, 264, 270, 271, 273, 280 adiacenti, 201 aggregazione, 108, 109, 161, 227, 2 2 9 232,234 al-Khwarizmi, Muhammad, 1 alberi, 2 alberi cardinali, 143, 144, 191 alberi di Fibonacci, 165, 166, 197 alberi ordinali, 144-148, 264 albero AVL, 165, 167, 169, 174, 187 albero BFS, 2 6 4 - 2 6 6 , 270, 280 albero binario, 113-124, 127, 133-138, 142, 143, 145, 148, 149, 162, 165, 283 albero binario di ricerca, 162, 165 albero dei cammini minimi, 316 albero dei suffissi, 195, 196 albero DFS, 267-271, 275 albero di ricoprimento, 264, 266, 307, 308,310-312,314 albero euclideo, 307

algoritmo algoritmo algoritmo algoritmo algoritmo algoritmo algoritmo

di r-approssimazione, 337 di Bellman-Ford, 295, 302 di Dijkstra, 295, 297 di Floyd-Warshall, 305 di Strassen, 60, 68, 215 esponenziale, 11 goloso, 199, 224, 225, 250, 251,338 algoritmo polinomiale, 11, 16—18, 66, 218, 2 2 2 , 3 1 8 , 3 1 9 , 3 2 1 , 3 2 5 , 326,335-337, 340-342,344, 348, 349 all pair shortest path, 296 all'indietro, 265, 269 altezza, 95, 117 ALVI E, 3, 4, 7, 12, 13, 17, 28, 31, 32, 36, 39, 46, 49, 5 1 , 6 2 , 6 9 , 7 4 , 76, 79, 94, 98, 102, 107, 110, 118, 120, 122, 123, 131, 135, 141, 148, 158, 161, 165, 170, 1 7 7 , 1 7 9 , 1 8 2 , 188, 189, 194, 2 2 1 , 2 2 4 , 2 2 8 , 2 3 3 , 237, 243, 248, 2 5 5 - 2 5 9 , 267, 270, 273, 279, 288, 2 9 1 , 2 9 3 , 2 9 9 , 303, 3 0 6 , 3 1 2 , 3 1 5 , 320, 338, 344, 347 analisi ammortizzata, 99, 100, 102, 107, 108, 110-112 antenato, 114 approssimazione, 59, 225, 229, 317, 318, 3 3 7 , 3 3 8 , 340-344, 3 4 7 - 3 4 9

approssimazione di Stirling, 290 archi, 199 arco, 113, ITI arco back, 269 arco cross, 269 arco forward, 269 array associativo, 156 array bidimensionale, 56, 66, 68, 79, 91, 130, 140, 149, 208 ASCII, 10 Ask, 241 assegnazione delle lunghezze d'onda, 216, 217 assegnazione di valori, 307, 322, 323, 326,328 A T & T Bell Labs, 2 A T & T call graph, 226 authority, 246 auto-organizzazione, 99, 102, 103, 108, 111 autorità, 246 awersariale, 94 B-albero, 171-177, 180, 197 B-tree, 171 backtrack, 15, 22 backup, 75 basi di dati, 170 BFS, 262 bilanciato, 121 bit o binary digit, 2, 10 bisaccia, 77, 79, 80, 82, 317, 336 bitmap, 178 blocchi, 171 Breadth-First Search (BFS), 262 bucket, 219 cammino (orientato o meno), 201, 205, 213 cammino hamiltoniano, 206, 207, 342

cammino minimo (pesato o meno), 202203,205,295,297-301,303306, 342 caso medio, 19 caso pessimo, 19 casuale, 52-53 Central Processing Unit, 28 certificati polinomiali, 17 chaining, 157 chiave, 37 chiave di ricerca, 151 chiusura transitiva, 213, 214 ciclico, 270 ciclo, 201, 302 ciclo euleriano, 127, 128, 149, 208, 274 ciclo hamiltoniano, 207, 208, 340, 341 ciclo orientato, 205 cima della pila, 254, 258, 259 classe NP, 17, 208, 321 classe P, 319 clausole, 322-324, 329-334, 336, 348 dient, 156 dipping, 57 clique, 204 cluster, 161, 227, 307, 308 cluster analysis, 307 coda con priorità, 281 coefficiente di aggregazione, 227 collisione, 156, 157, 161 complessità computazionale, 36 complessità in spazio, 19 complessità in tempo, 19 completamente bilanciato, 121 completo, 121 completo a sinistra, 133-135, 283-285, 292 componente connessa, 203, 204, 214, 230, 253, 273-274, 302, 307, 310,319

componente fortemente connessa, 205, 274,275 computer graphics, 56 concentratore, 246, 248 congettura di Goldbach, 5 connesso, 203 contrazione, 211 convesso, 324, 325 Cook, Stephen, 18 corrispondenza biunivoca, 13, 136, 145, 146, 148, 150, 191, 218, 271 costo ammortizzato, 28, 100, 102, 108— 110, 197, 288, 301 costo medio, 52, 98, 99, 160 costo minimo, 63, 64, 68-70, 82, 295, 344 costo ottimo, 69 costo uniforme, 19 crawler, 241, 261, 262 credito, 109 cricca, 204, 216, 218, 221, 227, 230, 237,332 Crick, Francis, 2 cut, 308 cut-off, 235 Data Base Management System, 170 data mining, 306 database, 170 dati satellite, 151, 162 decomponibili, 119, 121 denso, 200 Depth-First Search (DFS), 267 di arrivo, 205 di destinazione, 205 di partenza, 205 diametro, 226, 227, 230, 231, 265 digital fingerprint, 156 dimensione, 10, 116, 151, 200 dinamico, 27, 152

Directed Acyclic Graph (DAG), 271, 272, 275,278, 280 diretto, 205 discendente, 114 disco, 171 distance vector, 295 distanza (pesata o meno), 202-203, 296 distribuzione del grado, 226, 234 distribuzione di Bernoulli, 228, 229 distribuzione di Poisson, 229 disuguaglianza triangolare, 341-344 divide et impera, 23, 40, 41, 43-45, 47, 49, 60, 64, 65, 69, 70, 80, 82, 119 divisione, 175 dizionario, 151 embedding planare, 2 1 1 , 2 1 2 entrante, 205 entropia, 2 equazioni di ricorrenza, 21, 23, 42, 54, 80, 82 Erickson, Jeff, 353 esponenziale, 7 espressioni regolari, 189 estremo, 201 etichettato, 201 euristiche, 317, 345, 348 ExpertRank, 241 Extensible Markup Language (XML), 131 fabbriche di link, 245 fattore di caricamento, 158 Fibonacci, 21, 165, 166, 301, 315 figlio (sinistro, destro), 113-114, 115, 124, 133, 134, 136, 138, 144, 162-164, 285 file system, 262 finale, 205 finger search, 182

First Come First Served (FCFS), 29 First In First Out (FIFO), 259 foglie, 114 foresta di ricoprimento, 307 forma normale congiuntiva, 322, 327, 348 forma normale disgiuntiva, 328 formula booleana, 322, 326, 327, 348 formula di Stirling, 229 frame buffer, 56, 57 fratello, 114 fuori linea, 104, 107, 111 fusione, 46-49, 51, 53, 55, 69, 177, 180, 181,257, 293, 295 Godei, Kurt, 4 gadget, 331, 336 gap di complessità, 60, 340 girovita (girth), 316 Google, 241, 245 GoogleMaps, 295 grado, 144, 201, 205, 227, 229 grado dell'albero, 144 grado in ingresso, 205 grado in uscita, 205 grafo a intervalli, 216—219, 221-223, 251 grafo bipartito, 206, 2 1 1 , 2 1 2 grafo completo, 204, 211, 307, 340, 342, 349 grafo etichettato, 201 grafo fortemente connesso, 205 grafo planare, 211, 216 grafo regolare, 230 grafo orientato, 205, 225, 232, 240, 241, 2 5 1 , 2 6 1 , 2 6 8 , 270, 271,274, 275, 277, 280, 294, 296, 322 grafo pesato, 201, 208, 209, 295, 296 greedy o goloso, 224

Harel, David, 3 hash, 151, 154-161, 171, 178, 179, 183, 187, 189, 190, 197, 266 hash doppio, 161 heap, 283, 284 heap di Fibonacci, 301, 315 Heapsort, 292 heaptree, 283-285 host, 262 hub, 246 Hypertext Induced Topic Selection (HITS), 241, 246-249 HyperText Markup Language (HTML), 262 in avanti, 269 in linea, 103, 235, 239, 241, 244, 268, 337,347 in loco, 36, 47, 51, 289, 291, 292 incidente, 201 indecidibile, 6 independent set, 221 indice, 170 information retrieval, 177, 183 iniziale, 205 inorder, 120 insertion sort, 31 insieme indipendente, 199, 221-225, 230, 250, 251,317, 331,334, 335 Internet Protocol (IP), 262, 293 intervallo, 217 intrinsecamente difficile, 318 intrusion detection, 71 invariante di scala, 235, 239 inversione, 105-107 isolato, 201 isomorfi, 212 iterativa, 155 k-ari, 143

kernel, 161, 162 knapsack, 77 Landau, Gad, 19 Last In First Out (LIFO), 253 lati, 200 Least Recently Used (LRU), 103 legge di potenza, 235 letterali, 322 Levin, Leonid, 18 limite inferiore, 36, 40, 46, 47, 60, 146, 172, 189, 197, 325, 342 limite superiore, 36, 40, 60, 98, 100102,235, 347 lineare, 161 link, 225 link analysis, 241 lista, 2, 3, 25 lista circolare, 88 lista circolare doppia, 89 lista di adiacenza, 209, 210, 212, 263, 264,267, 272, 279 lista doppia, 86, 87, 111, 123, 152154, 178,311 liste a salti, 83, 94 liste invertite, 151, 177-181, 183, 196, 197,239 livelli di memoria, 21, 171 longest common subsequence (LCS), 72 Lucas, Edouard, 6 lunghezza, 201 macchina di Turing, 5, 318 macro-vertici, 274, 275, 278, 280 MapQuest, 295 massimale, 203 master theorem, 42 match, 90 matrice, 56

matrice di adiacenza, 208, 210, 2 1 1 213, 241,242, 247, 327 memoization, 77 memoria principale, 49, 53, 161, 162, 171, 1 7 3 , 1 7 5 , 1 8 0 , 1 9 7 memoria secondaria, 49, 53, 161, 162, 171, 172, 175-177, 180 memoria virtuale, 161, 162 memorizzazione binarizzata, 144, 145, 280 mergesort, 47, 180, 189 Message-Digest Algorithm (MD), 155 microarray, 307 minimo albero di ricoprimento (MST), 307 minimo antenato comune (LCA), 113, 125-127, 129, 149, 150, 196, 322,342 minimo insieme convesso, 324 minimo insieme di campionamento, 334, 335 minimo ricoprimento tramite vertici, 331 modello matematico, 226 moltiplicazione veloce, 43, 60, 62 motori di ricerca, 178, 180, 239, 241, 250 Move-To-Front (MTF), 103 MSNMaps, 295 multigrafo, 207 navigatore casuale, 274 nodo, 113, 199 nodo critico, 167-169, 197 nodo interno, 114, 121, 143, 191,291, 304 non orientato, 204 non determinismo, 318 NP-completo, 18, 80, 216, 221, 317, 318,322,326, 3 2 8 - 3 3 1 , 3 3 4 337, 340-342, 348, 349

numeri di Fibonacci, 62, 166 numero cromatico, 216, 218, 219 numero di Catalan, 63, 142, 146 numero di Fibonacci, 21 numero di Ramsey, 230 numero di trasferimenti, 171, 197 Odifreddi, Piergiorgio, 19 offline, 104 online, 103 open addressing, 158 Open Directory Project (ODP), 262 Open Shortest Path First (OSPF), 295 opus libri (opere algoritmiche), 2, 28, 55,89, 99, 1 1 3 , 1 2 5 , 1 5 4 , 1 6 1 , 170, 1 7 7 , 2 1 5 , 2 3 9 , 256, 261, 2 9 3 , 3 0 6 , 338 ordinamento topologico, 253, 270-272,

280 ordinata, 144 ordinato, 152 ordine, 200 orientato, 205 ottimo, 36 output sensitive, 182 pacchetti, 2 9 3 - 2 9 5 packet switching, 293 padre, 114 page fault, 162 PageRank, 2 4 1 - 2 4 6 , 2 4 8 , 2 4 9 p a r a d i g m a della ricerca locale,

344

parentesi bilanciate, 143, 145-148, 150 partizione, 75 passo elementare, 18 pattern matching, 196 peer-to-peer, 1 5 4 , 1 5 6 peggiore, 19 perfect match, 90, 206 perfetto, 90, 157

permutazione, 105, 159, 160, 206, 207 pesato, 201 peso, 281 peso di un cammino, 203 piccolo mondo, 230—234 pila, 253 pivot, 50-53, 94 pixel, 56, 57 polinomiale, 8 polinomialmente trasformabile, 325, 326, 334 Portable Document Format (PDF), 257 posizionale, 143 posting, 178 postorder, 120 Postscript, 256, 257 potenziale, 47, 110, 195, 245 power law, 235 predecessore, 95 prefisso, 183 preorder, 120 primaria, 170 principio di località temporale, 103 probing, 159 problem solving, 2 problema aperto, 326 problema dei matrimoni stabili, 83, 89, 90, 92, 93, 111 problema del commesso viaggiatore, 338, 3 4 0 - 3 4 2 , 3 4 4 - 3 4 6 , 349 problema della fermata, 4—6, 10 problema della soddisfacibilità, 322 problema di decisione, 319, 322, 326, 3 2 8 , 3 4 0 , 348 problema di ottimizzazione, 77, 328, 337, 3 4 0 , 3 4 4 , 348 problemi computazionali, 1 - 3 , 6, 11, 21, 32, 205, 317, 321, 329, 335, 337, 348

problemi di ottimizzazione, 69 problemi intrattabili, 11 problemi NP-completi, 18 problemi trattabili, 11, 14 prodotto, 57 prodotto scalare, 57 profondità, 117 progettazione di componenti, 331 programmazione dinamica, 23, 62, 6 9 7 2 , 7 5 - 8 0 , 1 3 0 , 2 2 5 , 3 0 4 , 305 proprietà fondamentale delle occorrenze, 195

quadratica, 161

reti biologiche, 226 reti complesse, 225, 227, 230, 231, 2 3 4 236,250 reti di informazioni, 226 reti sociali, 225, 226, 231 reti tecnologiche, 226 ricerca, 37 ricerca binaria, 37, 3 9 ^ 3 , 96, 157, 163, 172, 174-176, 187, 328, 348 ricerca locale, 317, 344-346, 348 ricerca sequenziale, 37 ricoprimento, 334 rotazioni, 168-170, 174, 187, 197 round robin, 89, 111 router, 190, 293-295 Routing Information Protocol, 295

query, 125, 127, 129, 131, 148, 149, 239 quicksort, 49, 94, 99 raddoppio, 28, 130 radice, 113 radiosità, 59 radixsort, 189 raggruppamenti di nodi, 227 random, 53, 83, 94, 97-99, 102, 111, 153,228,233,237 Random Access Machine (RAM), 19 rango, 42, 90, 239, 270 rank, 270 rapporto aureo, 22 rappresentazione implicita, 133, 135, 136, 218,283, 284 rappresentazione succinta, 133, 135, 136, 138,142,146-148 rastering, 57 record, 170, 172-175 recupero dei documenti, 177 red-black tree, 177 rendering, 57-59 restrizione, 334

scheduling, 28, 29, 215, 222 search spam, 240, 248 secondarie, 170 Secure Hash Algorithm (SHA), 155 secure sockets layer, 18 segmento, 33 segmento di somma massima, 32—36, 81 selection sort, 30 selezione, 54 self-adjusting, 103 self-organizing, 103 semplice, 202 sequenza, 3 sequenza di scansione, 159 sequenza lineare, 23-25, 27, 29, 37, 55, 83,84,217 sequenza random, 97 server, 156 Shannon, Claude, 2, 10 Shortest Job First (SJF), 29 shortest path, 295-297 signature file, 178

pseudo-polinomiale, 80

similitudine, 334 single source shortest path (SSSP), 297 sistema lineare ottico, 217 sistemi di recupero dei documenti, 177 sistemi distribuiti, 156 sistemi distribuiti di condivisione dei file, 156 Six Degrees of Kevin Bacon, 225 skip list, 94, 177 small world, 231 snippet, 240 software, 3, 4 soglia, 230 somma telescopica, 106, 110 sostituzione locale, 329 sotto-problema, 41, 43, 63, 69-71, 7 5 79,225 sotto-sequenza, 33, 50, 72-74, 80, 328 sotto-sequenza comune, 72-74, 80, 328 sotto-sequenza comune più lunga (LCS), 72 sottoalbero, 114 sottografo, 203 sottografo indotto, 203, 204, 221, 227, 230, 2 4 1 , 3 3 8 spanning tree, 264, 307 sparso, 200 spazio, 19 spider, 241 split, 175 stabile, 81, 90 statico, 152 Structured Query Language (SQL), 170 Sudoku, 14-18, 317 suffix tree, 195 surfer, 242 sweeping line, 219 tabella di routing, 294, 295 tabelle hash, 156

taglio, 308 task, 28 tempo, 19 teorema di Cook-Levin, 326-328 teorema di Kuratowski-Pontryagin-Wagner, 211 teorema di Perron-Frobenius, 249, 250 teorema fondamentale delle ricorrenze, 42-44, 46, 48, 5 4 , 5 5 , 6 1 , 8 2 teoria di Ramsey, 230 terminali, 201 terminazione, 4 termine, 178 testo, 178 topic drift, 249 Torri di Hanoi, 6—10, 16 tour, 340-347 trasformata veloce di Fourier, 46 trasversale, 269 trie, 184 trie compatto, 190 trovare, 17 Turing, Alan, 4 unario, 190, 194 Unicode, 10 Uniform Resource Locator (URL), 261— 262 union-find, 100 universo, 151, 152, 154, 155 Unix, 2 uscente, 205 verificare, 17 vertici, 199 vettore di rango, 242, 249 visita, 119, 262 visita anticipata, 120 visita in ampiezza, 133, 262 visita in profondità, 267

visita per livelli, 133 visita posticipata, 120 visita simmetrica, 120 von Neumann, John, 19 Watson, James, 2 World Wide Web (WWW), 225 YahooMaps, 295 zaino, 77 zone, 52