Algoritmi e Struttur e Dati (Mod. B)

Algoritmi e Strutture Dati (Mod. B) Algoritmi su grafi Ricerca in ampiezza (Breadth-First Search)

s = C B C A F D E Definizione del problema Attraversamentodi un grafo Dato un grafo G=<V,E>ed un vertice sdi V (det-to sorgente), esplorare ogni vertice raggiungibile nel grafo dal vertice s

Definizione del problema Attraversamentodi un grafo Dato un grafo G=<V,E>ed un vertice sdi V (det-to sorgente), esplorare ogni vertice raggiungibile nel grafo dal vertice s s = C B C A F D E

Definizione del problema Attraversamentodi un grafo Dato un grafo G=<V,E>ed un vertice sdi V (det-to sorgente), esplorare ogni vertice raggiungibile nel grafo dal vertice s s = C B C A F è l’unico vertice non raggiungibile F D E

Algoritmo BFS per alberi Visita-Ampiezza(T:albero) Coda={T} while Coda  do P= Testa[Coda] “visita P” for each “figlio F di P da sinistra” do Accoda(Coda,F) Decoda(Coda) Nel nostro algoritmo generico per i grafi, come operazione di “visita”di un vertice useremo la me-morizzazione di quale sia il “padre” (o avo imme-diato) del vertice durante la BFS.

Algoritmo BFS: I BSF(G:grafo, s:vertice) pred[s]= Nil Coda = {s} while Coda   do u= Testa[Coda] for each v Adiac(u) do pred[v]= u Accoda(Coda,v) Decoda(Coda) Visita-Ampiezza(T:albero) Coda= {T} while Coda  do P= Testa[Coda] “visita P” for each “figlio F di P da sinistra” do Accoda(Coda,F) Decoda(Coda)

Algoritmo BFS I F B C I A M D E L H G

D F A D E E C F D G D I H G H Algoritmo BFS I F B C I A M D E L H G A B C D E F G H I L M B C B A C B E I F M L

Algoritmo BFS I F B C I A M D E L H G Coda:{}

for each v  Adiac(u) do pred[v]= u Accoda(Coda,v) Decoda(u) Algoritmo BFS I s = F F B C I A M D E L H G Coda:{F}

D I for each v  Adiac(u) do pred[v]= u Accoda(Coda,v) Decoda(u) Algoritmo BFS I s = F F B C I A M D E L H G u = F Coda:{B,D,I} B F

F A for each v  Adiac(u) do pred[v]= u Accoda(Coda,v) Decoda(u) Algoritmo BFS I s = F F B C I A M D E L H G u = B Coda:{D,I,C,A,F} B C

E C F for each v  Adiac(u) do pred[v]= u Accoda(Coda,v) Decoda(u) Algoritmo BFS I s = F F B C I A M D E L H G A D Coda:{I,A,C,F,A,F,C,E} u = D

H for each v  Adiac(u) do pred[v]= u Accoda(Coda,v) Decoda(u) Algoritmo BFS I s = F F B C I A M D E L H G u = I Coda:{A,C,F,A,F,C,E,F,H} I F

D for each v  Adiac(u) do pred[v]= u Accoda(Coda,v) Decoda(u) Algoritmo BFS I s = F F B C I A M D E L H G u = A Coda:{C,F,A,F,C,E,F,H,B,D} A B

D E for each v  Adiac(u) do pred[v]= u Accoda(Coda,v) Decoda(u) Algoritmo BFS I s = F F B C I A M D E L H G C B u = C Coda:{F,A,F,C,E,F,H,B,D,B,E,D}

D I for each v  Adiac(u) do pred[v]= u Accoda(Coda,v) Decoda(u) Algoritmo BFS I s = F F B C I A M D E L H G B F u = F Coda:{A,F,C,E,F,H,B,D,B,E,D,B,D,I}

Algoritmo BFS I: problema • È necessario ricordarsi dei nodi che abbimo già visitato per non rivisitarli nuovamete. • Dobbiamo distinguere tra i vertici non visitati, quelli visitati e quelli processati

Algoritmo BFS I: problema • È necessario ricordarsi dei nodi che abbimo già visitato per non rivisitarli nuovamete. • Dobbiamo distinguere tra i vertici non visitati, quelli visitati e quelli processati • un vertice è stato visitato se è comparso nella coda • un vertice è stato non visitato se non è stato ancora visitato • un vertice è stato processato se tutti i vertici ad esso adiacenti sono stati visitati

Algoritmo BFS II: soluzione • Per distinguere tra i vertici non visitati, quelli visitati, e quelli processati colo-reremo • ogni vertice visitato di grigio • ogni vertice non visitato di bianco • ogni vertice processato di nero

Algoritmo BFS II: soluzione • Per distinguere tra i vertici non visitati, quelli visitati, e quelli processati colo-reremo • ogni vertice visitato di grigio • ogni vertice non visitato di bianco • ogni vertice processato di nero • Vengono accodati solo i vertici che non sono ancora stati visitati • I vertici in coda saranno i vertici visitati e non ancora processati • I vertici processati non vengono più visitati

s = F for each v  Adiac(u) do if colore[v] = Bianco then colore[v] = Grigio pred[v]= u Accoda(Coda,v) Decoda(Coda,u); colore[u]= Nero Algoritmo BFS II F B C I A M D E L H G Coda:{F}

s = F D I for each v  Adiac(u) do if colore[v] = Bianco then colore[v] = Grigio pred[v]= u Accoda(Coda,v) Decoda(Coda,u); colore[u]= Nero Algoritmo BFS II F B C I A M D E L H G u = F Coda:{F} B F

s = F D I for each v  Adiac(u) do if colore[v] = Bianco then colore[v] = Grigio pred[v]= u Accoda(Coda,v) Decoda(Coda,u); colore[u]= Nero Algoritmo BFS II F B C I A M D E L H G u = F Coda:{F,B,D,I} B F

s = F F A for each v  Adiac(u) do if colore[v] = Bianco then colore[v] = Grigio pred[v]= u Accoda(Coda,v) Decoda(Coda,u); colore[u]= Nero Algoritmo BFS II F B C I A M D E L H G u = B Coda:{B,D,I} B C

s = F F A for each v  Adiac(u) do if colore[v] = Bianco then colore[v] = Grigio pred[v]= u Accoda(Coda,v) Decoda(Coda,u); colore[u]= Nero Algoritmo BFS II F B C I A M D E L H G u = B Coda:{B,D,I,C,A} B C

s = F E C F for each v  Adiac(u) do if colore[v] = Bianco then colore[v] = Grigio pred[v]= u Accoda(Coda,v) Decoda(Coda,u); colore[u]= Nero Algoritmo BFS II F B C I A M D E L H G A D Coda:{D,I,C,A} u = D

s = F E C F for each v  Adiac(u) do if colore[v] = Bianco then colore[v] = Grigio pred[v]= u Accoda(Coda,v) Decoda(Coda,u); colore[u]= Nero Algoritmo BFS II F B C I A M D E L H G A D Coda:{D,I,C,A,E} u = D

s = F H for each v  Adiac(u) do if colore[v] = Bianco then colore[v] = Grigio pred[v]= u Accoda(Coda,v) Decoda(Coda,u); colore[u]= Nero Algoritmo BFS II F B C I A M D E L H G D I F Coda:{I,C,A,E} u = I

s = F H for each v  Adiac(u) do if colore[v] = Bianco then colore[v] = Grigio pred[v]= u Accoda(Coda,v) Decoda(Coda,u); colore[u]= Nero Algoritmo BFS II F B C I A M D E L H G I F Coda:{I,C,A,E,H} u = I

s = F D E for each v  Adiac(u) do if colore[v] = Bianco then colore[v] = Grigio pred[v]= u Accoda(Coda,v) Decoda(Coda,u); colore[u]= Nero Algoritmo BFS II F B C I A M D E L H G C B Coda:{C,A,E,H} u = C

s = F D for each v  Adiac(u) do if colore[v] = Bianco then colore[v] = Grigio pred[v]= u Accoda(Coda,v) Decoda(Coda,u); colore[u]= Nero Algoritmo BFS II F B C I A M D E L H G A B Coda:{A,E,H,G} u = A

s = F D G for each v  Adiac(u) do if colore[v] = Bianco then colore[v] = Grigio pred[v]= u Accoda(Coda,v) Decoda(Coda,u); colore[u]= Nero Algoritmo BFS II F B C I A M D E L H G E C Coda:{E,H,G} u = E

s = F G for each v  Adiac(u) do if colore[v] = Bianco then colore[v] = Grigio pred[v]= u Accoda(Coda,v) Decoda(Coda,u); colore[u]= Nero Algoritmo BFS II F B C I A M D E L H G H I Coda:{H,G} u = H

s = F for each v  Adiac(u) do if colore[v] = Bianco then colore[v] = Grigio pred[v]= u Accoda(Coda,v) Decoda(Coda,u); colore[u]= Nero Algoritmo BFS II F B C I A M D E L H G Coda:{G}

s = F H for each v  Adiac(u) do if colore[v] = Bianco then colore[v] = Grigio pred[v]= u Accoda(Coda,v) Decoda(Coda,u); colore[u]= Nero Algoritmo BFS II F B C I A M D E L H G G E Coda:{G} u = G

s = F H for each v  Adiac(u) do if colore[v] = Bianco then colore[v] = Grigio pred[v]= u Accoda(Coda,v) Decoda(Coda,u); colore[u]= Nero Algoritmo BFS II F B C I A M D E L H G G E Coda:{} u = G

Inizializzazione Accodamento dei soli nodi non visitati Algoritmo BFS II BSF(G:grafo, s:vertice) for each verticeu V(G) - {s} docolore[u] = Bianco pred[u]= Nil colore[s] = Bianco pred[s]= Nil Coda = {s} while Coda   do u= Testa[Coda] for each v Adiac(u) do if colore[v] = Bianco then colore[v] = Grigio pred[v]= u Accoda(Coda,v) Decoda(Coda) colore[u] = Nero

O(|V|) O(|Eu|) Eu = lunghezza della lista di adiacenza di u Algoritmo BFS II: complessità BSF(G:grafo, s:vertice) for each verticeu V(G) - {s} docolore[u] = Bianco pred[u]= Nil colore[s] = Bianco pred[s]= Nil Coda = {s} while Coda   do u= Testa[Coda] for each v Adiac(u) do if colore[v] = Bianco then colore[v] = Grigio pred[v]= u Accoda(Coda,v) Decoda(Coda) colore[u] = Nero

O(|V|) O(|E|) E=dimensione delle liste di adiacenza. Numero di archi Algoritmo BFS II: complessità BSF(G:grafo, s:vertice) for each verticeu V(G) - {s} docolore[u] = Bianco pred[u]= Nil colore[s] = Bianco pred[s]= Nil Coda = {s} while Coda   do u= Testa[Coda] for each v Adiac(u) do if colore[v] = Bianco then colore[v] = Grigio pred[v]= u Accoda(Coda,v) Decoda(Coda) colore[u] = Nero

Algoritmo BFS II: complessità L’algoritmo di visita in breadth-First impiega tempo proporzionale alla somma del numero di vertici e del numero di archi (dimensione delle liste di adiacenza). T(V,E)=O(|V|+|E|)

Numero minimo di archi tra i vertici Definizione del problema Attraversamentodi un grafo Dato un grafo G=<V,E>ed un vertice sdi V (det-to sorgente), esplorare ogni vertice raggiungibile nel grafo dal vertice s Calcolare anche la distanza das di tutti i vertici raggiungibili s = C B C A F D E

B dist[B]=dist[E]= =dist[D]=1 C A F F dist[A]=2 D dist[F]= E Definizione del problema Attraversamentodi un grafo Dato un grafo G=<V,E>ed un vertice sdi V (det-to sorgente), esplorare ogni vertice raggiungibile nel grafo dal vertice s Calcolare anche la distanza das di tutti i vertici raggiungibili s = C

Inizializzazione Aggiorna- mento delle distanze Algoritmo BFS III BSF(G:grafo, s:vertice) for each verticeu V(G) - {s} docolore[u] = Bianco dist[u]=  pred[u]= Nil colore[s] = Bianco pred[s]= Nil dist[s]= 0 Coda = {s} while Coda   do u= Testa[Coda] for each v Adiac(u) do if colore[v] = Bianco then colore[v] = Grigio dist[v]= dist[u] + 1 pred[v]= u Accoda(Coda,v) Decoda(Coda) colore[u] = Nero s

for each verticeu V(G) - {s} do... dist[u]=  ... ... dist[s]= 0 Inizializzazione for each v Adiac(u) do if colore[v] = Bianco then ... dist[v]=dist[u]+1 Aggiornamento delle distanze  1 0  B   1 C 2 A F  1 D E Algoritmo BFS III: calcolo distanze minime

Correttezza di BFS III Sia dato un grafoG=<V,E> (orientato o non) e un vertice sorgente s: • durante l’esecuzione dell’algoritmo BFS(G,s), vengono esaminati tutti i vertici di Vraggiungibili da s; • Prima di dimostrare la correttezza di BFS, dimostreremo alcune proprietà dei percorsi minimi.

Algoritmi e Struttur e Dati (Mod. B)