1 / 88

Algoritmi e Struttur e Dati (Mod. B)

Algoritmi e Struttur e Dati (Mod. B). Algoritmi su grafi Ricerca in ampiezza ( Breadth - F irst S earch). s = C. B. C. A. F. D. E. Definizione del problema. Attraversamentodi un grafo

ulla-sears
Download Presentation

Algoritmi e Struttur e Dati (Mod. B)

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


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

  2. 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

  3. 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

  4. 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

  5. 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.

  6. 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)

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

  8. 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

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

  10. 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}

  11. 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

  12. 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

  13. 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

  14. 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

  15. 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

  16. 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}

  17. 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}

  18. 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

  19. 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

  20. 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

  21. 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

  22. 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}

  23. 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

  24. 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

  25. 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

  26. 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

  27. 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

  28. 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

  29. 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

  30. 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

  31. 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

  32. 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

  33. 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

  34. 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

  35. 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

  36. 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

  37. 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

  38. 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

  39. 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}

  40. 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

  41. 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

  42. 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

  43. 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

  44. 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

  45. 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|)

  46. 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

  47. 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

  48. 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

  49. 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

  50. 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.

More Related