La presentazione è in caricamento. Aspetta per favore

La presentazione è in caricamento. Aspetta per favore

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

Presentazioni simili


Presentazione sul tema: "Algoritmi e Strutture Dati (Mod. B) Algoritmi su grafi Ricerca in ampiezza (Breadth-First Search)"— Transcript della presentazione:

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

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

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

4 Definizione del problema A B C F D E s = C F è lunico vertice non raggiungibile Attraversamentodi un grafo Dato un grafo G= ed un vertice s di V (det- to sorgente), esplorare ogni vertice raggiungibile nel grafo dal vertice s

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}{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 A B C E G F H I L D M

8 A B C E F H I L D M G ABCDEFGHILMABCDEFGHILM B C B A C B I F M L DAI D EDGDF C EGH E H F

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

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

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

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

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

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

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

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

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

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 Algoritmo BFS II A B C E G F H I L D M s = F Coda:{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

23 Algoritmo BFS II A B C E G F H I L D M Coda:{F} u = F B I D F 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

24 Algoritmo BFS II A B C E G F H I L D M Coda:{F,B,D,I} u = F B I D F 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

25 Algoritmo BFS II A B C E G F H I L D M Coda:{B,D,I} u = B C AF B 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

26 Algoritmo BFS II A B C E G F H I L D M Coda:{B,D,I,C,A} u = B C AF B 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

27 Algoritmo BFS II A B C E G F H I L D M Coda:{B,D,I,C,A} u = B C AF B 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

28 Algoritmo BFS II A B C E G F H I L D M Coda:{D,I,C,A} u = D 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 A F C E D

29 Algoritmo BFS II A B C E G F H I L D M Coda:{D,I,C,A,E} u = D 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 A F C E D

30 Algoritmo BFS II A B C E G F H I L D M Coda:{D,I,C,A,E} u = D 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 A F C E D

31 Algoritmo BFS II A B C E G F H I L D M Coda:{I,C,A,E} u = I 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 D F H I

32 Algoritmo BFS II B G F I L D M A C E H Coda:{I,C,A,E,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 u = I F H I

33 Algoritmo BFS II A B C E G F H I L D M Coda:{C,A,E,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 u = C B ED C

34 Algoritmo BFS II A B C E G F H I L D M Coda:{C,A,E,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 u = C B ED C

35 Algoritmo BFS II A B C E G F H I L D M Coda:{A,E,H,G} 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 u = A B D A

36 Algoritmo BFS II A B C E G F H I L D M Coda:{A,E,H,G} 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 u = A B D A

37 Algoritmo BFS II A B C E G F H I L D M Coda:{E,H,G} 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 u = E C GD E

38 Algoritmo BFS II A B C E G F H I L D M Coda:{H,G} 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 u = H I G H

39 Algoritmo BFS II A B C E G F H I L D M Coda:{G} 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

40 Algoritmo BFS II A B C E G F H I L D M 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 u = G E H G Coda:{G}

41 Algoritmo BFS II A B C E G F H I L D M 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 u = G E H G Coda:{}

42 Algoritmo BFS II BSF(G:grafo, s:vertice) for each vertice u V(G) - {s} do colore[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 Inizializzazione Accodamento dei soli nodi non visitati

43 Algoritmo BFS II: complessità BSF(G:grafo, s:vertice) for each vertice u V(G) - {s} do colore[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 u |) E u = lunghezza della lista di adiacenza di u

44 Algoritmo BFS II: complessità BSF(G:grafo, s:vertice) for each vertice u V(G) - {s} do colore[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

45 Algoritmo BFS II: complessità Lalgoritmo 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 Definizione del problema Attraversamentodi un grafo Dato un grafo G= ed un vertice s di V (det- to sorgente), esplorare ogni vertice raggiungibile nel grafo dal vertice s Calcolare anche la distanza da s di tutti i vertici raggiungibili F A B C D E s = C Numero minimo di archi tra i vertici

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

48 Algoritmo BFS III BSF(G:grafo, s:vertice) for each vertice u V(G) - {s} do colore[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 Aggiorna- mento delle distanze Inizializzazione

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

50 Sia dato un grafo G= (orientato o non) e un vertice sorgente s: ¶ durante lesecuzione dellalgoritmo BFS(G,s), vengono esaminati tutti i vertici di V raggiungibili da s; ò Prima di dimostrare la correttezza di BFS, dimostreremo alcune proprietà dei percorsi minimi. Correttezza di BFS III

51 Percorsi minimi Un percorso minimo in un grafo G= tra due vertici s e v è un percorso da s a v che contiene il minimo numero di archi. A B D E F C s v Questo è un percorso minimo tra A e E Questo NON è un percorso minimo tra A e E

52 Percorsi minimi Un percorso minimo in un grafo G= tra due vertici s e v è un percorso da s a v che contiene il minimo numero di archi. A B D E F C s v Questo è un percorso minimo tra A e C Questo è un percorso minimo tra A e C Possono esistere più percorsi minimi tra due vertici

53 Percorsi minimi Un percorso minimo in un grafo G= tra due vertici s e v è un percorso da s a v che contiene il minimo numero di archi. La distanza minima (s,v) tra due vertici s e v è la lunghezza (numero di archi) di un percorso minimo tra s e v. A B D E F C s v (A,C) = 2 La distanza minima tra due vertici è unica

54 Percorsi minimi: proprietà I Sia G= un grafo (orientato o non) e s un vertice di G. Allora per ogni arco (u,v) di E, vale quanto segue: (s,v) (s,u) + 1

55 Proprietà I: dimostrazione ¶u è raggiungibile da s: Allora anche v lo è. Il percorso minore da s a v in tal caso non può essere più lungo del percorso minore da s a u seguito dallarco (v,u), e quindi (s,v) (s,u) + 1 u v s (s,v) (s,u) u v s (s,u)= (s,v) Ci sono 2 casi: ¶ u è raggiungibile da s · u non è raggiungibile da s Allora (s,u)=, e nuovamente la disuguaglianza vale.

56 Percorsi minimi: proprietà II Sia G= un grafo (orientato o non). Supponiamo di eseguire BFS(G,s ). Al termine dellalgoritmo, per ogni vertice v di V, vale: dist[v] (s,v)

57 Proprietà II: dimostrazione Useremo induzione sul numero di volte che un vertice è messo nella coda, con Ipotesi Induttiva dist[v] (s,v), per ogni vertice BSF(G:grafo, s:vertice) for each vertice u V(G) - {s} do colore[u] = Bianco dist[u] = pred[u] = Nil dist[s] = 0 Coda = {s}... Passo Base: è quando s viene posto nella coda. Poiché dist[s] = 0 = (s,s) e dist[v] = (s,v) per ogni altro vertice v, lipotesi è verificata!

58 Proprietà II: dimostrazione BSF(G:grafo, s:vertice) … 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 Accoda(Coda,v) Decoda(Coda) Passo Induttivo: un vertice bianco v viene posto in coda processando un vertice u. Per ipotesi induttiva dist[u] (s,u). Dallassegnamento e dalla proprietà I risulta che:

59 Percorsi minimi: proprietà III Sia G= un grafo (orientato o non). Supponiamo di eseguire BFS(G,s) e che in coda siano presenti i vertici [v 1,…,v n ] ( v 1 è la testa). Allora: dist[v n ] dist[v 1 ] + 1 dist[v i ] dist[v i+1 ] per ogni i=1,…,n-1

60 Proprietà III: dimostrazione Dimostriamo per induzione sul numero di operazioni sulla coda. ¶ Passo Base: Inizialmente (1 operazione sulla coda), quando la coda contiene solo s, la proprietà certamente vale.

61 Proprietà III: dimostrazione Ipotesi Induttiva Dobbiamo dimostrare che la proprietà vale sia per le operazioni di accodamento che di estrazione dalla coda di un vertice. Denotiamo con [v 1 v 2 … v r ] coda, dove v 1 è la testa. Supponiamo che la proprietà valga alla k-esima operazione sulla coda che sarà [v 1 v 2 … v r ], cioè: dist[v n ] dist[v 1 ] + 1 dist[v i ] dist[v i+1 ]

62 Proprietà III: dimostrazione · Passo Induttivo Õ 1 : quando v 1 viene estratto, v 2 diventa la nuova testa (quando si svuota la proprietà vale banalmente). Allora risulta dist[v r ] dist[v 1 ]+1 dist[v 2 ]+1 e il resto delle disuguaglianze resta identico. Quindi la proprietà vale con v 2 come testa

63 Proprietà III: dimostrazione · Passo Induttivo Õ 2 : quando si accoda a [v 1 v 2 … v r ] il vertice v (nel codice) diventa il nuovo v r+1, [v 1 v 2 … v r v r+1 ], mentre il vertce v 1 è il vertice u la cui lista di adiacenza viene esaminata (nel codice). Allora vale dist[v r+1 ] = dist[v] dist[u]+1 = dist[v 1 ]+1 così come pure dist[v r ] dist[v 1 ]+1 = dist[u]+1 = dist[v] = dist[v r+1 ] Le altre uguaglianze restano invariate. E la proprietà vale! u = Testa[Coda] for each v Adiac(u) do if colore[v] = Bianco then dist[v] = dist[u] + 1 Accoda(Coda,v) Decoda(Coda)

64 Correttezza di BFS III Sia dato un grafo G= (orientato o non) e un vertice sorgente s: ¶ durante lesecuzione dellalgoritmo BFS(G,s), vengono esaminati tutti i vertici di V raggiungibili da s; · al termine dist[v] = (s,v) per ogni v V; ¸ se v s, uno dei percorsi minimi tra s e v è il percorso minimo da s a pred[v] seguito dallarco (pred[v],v).

65 Correttezza di BFS III: dimostrazione Dimostrazione: consideruamo il caso in cui il vertice v sia raggiungibile da s (vedere sul libro di testo il caso in cui v non è raggiungibile). Sia V k linsieme dei vertici a distanza (minima) k da s (cioè V k ={v V: (s,v)=k}). La dimostrazone procede per induzione su k, cioè sulla distanza di un nodo v da s. Ipotesi induttiva: v è colorato di grigio a dist[v] è assegnato k se v s, allora a pred[v] è assegnato u per qualche u V k-1 v è inserito nella coda

66 Correttezza di BFS III: dimostrazione Caso Base: Per k=0, V 0 ={s} (unico vertice a distanza 0 da s): linizializzazione colora s di grigio; dist[s] viene posto a 0; s è messo nella coda. Quindi lipotesi induttiva vale! Ipotesi induttiva: v è colorato di grigio a dist[v] è assegnato k se v s, allora a pred[v] è assegnato u per qualche u V k-1 v è inserito nella coda

67 Correttezza di BFS III: dimostrazione Caso induttivo: La coda non è mai vuota fino al termine. Una volta inserito un vertice u nella coda, né dist[u] né pred [u] cambiano il loro valore. Per il teorema precedente, se i vertici sono inseriti nellordine v 1,v 2,…,v r, la sequenza delle distanze è crescente monotonicamente (d [v i ] d [v i+1 ]) Ipotesi induttiva: v è colorato di grigio a dist[v] è assegnato k se v s, allora a pred[v] è assegnato u per qualche u V k-1 v è inserito nella coda

68 Correttezza di BFS III: dimostrazione Caso induttivo: Sia ora v V k ( k 1 ). Dalla proprietà di monotonicità, dal fatto che dist [v] k (per un teorema precedete) e dallipotesi induttiva, segue che v (se viene visitato) deve essere visitato dopo che tutti i vertici in V k-1 sono stati accodati. Poiché (s,v)=k, cè un percorso di k archi da s a u, e quindi anche un vertice u V k-1 tale che (u,v) E, cioè adiacente a v. Ipotesi induttiva: v è colorato di grigio a dist[v] è assegnato k se v s, allora a pred[v] è assegnato u per qualche u V k-1 v è inserito nella coda

69 Correttezza di BFS III: dimostrazione Caso induttivo: Supponiamo che u sia il primo dei vertici adiacenti a v che viene colorato di grigio (per induzione tutti i vertici in V k-1 sono grigi). Se così non fosse, BFS accoda ogni vertice grigio, quindi u prima o poi sarà in testa alla lista. A questo punto, viene esaminata la lista di adiacenza di u e v viene visitato (non accade prima perché v sta in V k e non è adiacente a vertici in V j e con j < k-1, e u è il primo adiacente per lipotesi in alto) Ipotesi induttiva: v è colorato di grigio a dist[v] è assegnato k se v s, allora a pred[v] è assegnato u per qualche u V k-1 v è inserito nella coda

70 Correttezza di BFS III: dimostrazione Caso induttivo: Poi v viene colorato di grigio da BFS. Viene assegnato dist[v]=dist[u]+1=k Viene assegnato pred[v]=u Viene messo v in coda. Essendo v un vertice arbitrario in V k, lipotesi induttiva è dimostrata per k! Ipotesi induttiva: v è colorato di grigio a dist[v] è assegnato k se v s, allora a pred[v] è assegnato u per qualche u V k-1 v è inserito nella coda

71 Correttezza di BFS III: dimostrazione Inoltre, se v V k, allora certamente (per ipotesi induttiva) sappiamo che pred[v] V k-1 È quindi possibile ottenere il percorso minimo da s a v prendendo il percorso minimo da s a pred[v] e aggiun- gendo larco (pred[v],v ). Ipotesi induttiva: v è colorato di grigio a dist[v] è assegnato k se v s, allora a pred[v] è assegnato u per qualche u V k-1 v è inserito nella coda

72 Alberi breadth-first A B C F D E s = A Un albero breadth-first di un grafo non orientato G = con sorgente s, è un albero libero G= tale che: G è un sottografo del grafo non orientato sottostante G v V se e solo se v è raggiungibile da s per ogni v V, il percorso da s a v è minimo

73 Alberi breadth-first B C D E F s = A Un albero breadth-first di un grafo non orientato G = con sorgente s, è un albero libero G= tale che: G è un sottografo del grafo non orientato sottostante G v V se e solo se v è raggiungibile da s per ogni v V, il percorso da s a v è minimo A Questo è un albero breadth-first

74 Alberi breadth-first B C D E F s = A Un albero breadth-first di un grafo non orientato G = con sorgente s, è un albero libero G= tale che: G è un sottografo del grafo non orientato sottostante G v V se e solo se v è raggiungibile da s per ogni v V, il percorso da s a v è minimo A Questo è un altro albero breadth-first

75 Alberi breadth-first B C D E F s = A Un albero breadth-first di un grafo non orientato G = con sorgente s, è un albero libero G= tale che: G è un sottografo del grafo non orientato sottostante G v V se e solo se v è raggiungibile da s per ogni v V, il percorso da s a v è minimo A Questo NON è un albero breadth-first! Perché?

76 Alberi breadth-first B C D E F s = A Un albero breadth-first di un grafo non orientato G = con sorgente s, è un albero libero G= tale che: G è un sottografo del grafo non orientato sottostante G v V se e solo se v è raggiungibile da s per ogni v V, il percorso da s a v è minimo A Perché il percorso da A ad E NON è minimo

77 Sottografo dei predecessori e BFS Lalgoritmo BFS eseguito su un grafo G = costruisce (nellarray pred[] ) il sottografo dei predecessori denotato con G pred =, dove: V pred = { v V : pred[v] Nil } {s} E pred = { (pred[v],v) E : v V pred - {s} } A B C E G F H I L D M

78 Sottografo dei predecessori e BFS A B C E G F H I L D M Lalgoritmo BFS eseguito su un grafo G = costruisce (nellarray pred[] ) il sottografo dei predecessori denotato con G pred =, dove: V pred = { v V : pred[v] Nil } {s} E pred = { (pred[v],v) E : v V pred - {s} }

79 Sottografo dei predecessori e BFS E F H I L M A C G D B Questo è un albero breadth-first di G Lalgoritmo BFS eseguito su un grafo G = costruisce (nellarray pred[] ) il sottografo dei predecessori denotato con G pred =, dove: V pred = { v V : pred[v] Nil } {s} E pred = { (pred[v],v) E : v V pred - {s} }

80 Sottografo dei predecessori e BFS E F H I L M A C D B G Questo è un altro albe- ro breadth-first di G Lalgoritmo BFS eseguito su un grafo G = costruisce (nellarray pred[] ) il sottografo dei predecessori denotato con G pred =, dove: V pred = { v V : pred[v] Nil } {s} E pred = { (pred[v],v) E : v V pred - {s} }

81 Sottografo dei predecessori e BFS E F H I L M A C D B G Questo è un altro albe- ro breadth-first di G Lalgoritmo BFS eseguito su un grafo G = costruisce (nellarray pred[] ) il sottografo dei predecessori denotato con G pred =, dove: V pred = { v V : pred[v] Nil } {s} E pred = { (pred[v],v) E : v V pred - {s} }

82 Alberi breadth-first e BFS Lalgoritmo BFS eseguito su un grafo G = costruisce in pred[] il sottografo dei predecessori G pred = in modo tale che G pred sia un albero breadth-first di G. E F H I L M A C D B G Questo è un grafo dei predecessori di G costruito da BFS Questo è un albero breadth-first di G

83 Alberi breadth-first e BFS Lalgoritmo BFS eseguito su un grafo G = costruisce in pred[] il sottografo dei predecessori G pred = in modo tale che G pred sia un albero breadth-first di G. E F H I L M A C D B G I percorsi da F a C e da F ad E non sono minimi Questo non è un grafo dei predecessori di G costruito da BFS Questo non è un albe- ro breadth-first di G

84 Alberi breadth-first e BFS Teorema: Lalgoritmo BFS eseguito su un grafo G= costruisce in pred[] il sottografo dei prede- cessori G pred = in modo tale che G pred sia un albero breadth-first di G. Dimostrazione: BFS assegna pred[v]=u solo se (u,v) E e (u,v)< (solo se v è raggiungibile da s). Quindi V pred consiste di vertici in V tutti raggiungibili da s Poiché G pred è un albero, contiene un unico percorso da s ad ogni vertice in V pred Usando induttivamente il teorema di correttezza (parte finale), segue che ognuno di questi percorsi è minimo.

85 Alberi breadth-first e BFS Teorema: Lalgoritmo BFS eseguito su un grafo G= costruisce in pred[] il sottografo dei prede- cessori G pred = in modo tale che G pred sia un albero breadth-first di G. Dimostrazione: Usando induttivamente il teorema di correttezza (parte finale), segue che ognuno di questi percorsi è minimo. Induzione sulla distanza k di v da s. Passo Base: Se k=0 segue banalmente. Sia dato un grafo G= (orientato o non) e un vertice sorgente s: ¸ se v s, uno dei percorsi minimi tra s e v è il percorso minimo da s a pred[v] seguito dallarco (pred[v],v).

86 Alberi breadth-first e BFS Teorema: Lalgoritmo BFS eseguito su un grafo G= costruisce in pred[] il sottografo dei prede- cessori G pred = in modo tale che G pred sia un albero breadth-first di G. Dimostrazione: Usando induttivamente il teorema di correttezza (parte finale), segue che ognuno di questi percorsi è minimo. Induzione sulla distanza k di v da s. Sia dato un grafo G= (orientato o non) e un vertice sorgente s: ¸ se v s, uno dei percorsi minimi tra s e v è il percorso minimo da s a pred[v] seguito dallarco (pred[v],v). Passo Induttivo: Il percorso tra s e pred[v] è minimo per induzione Ma allora per il teorema di correttezza lo è anche il percorso da s a pred[v] seguito dallarco (pred[v],v).

87 Applicazione di BFS: calcolo del percorso minimo tra due vertici Definizione del problema: Dato un grafo G ed due vertici s e v, stampare il percorso minimo che congiunge s e v. Sfruttando le proprietà di BFS che abbiamo dimostrato fin qui, possiamo facimente definire un algoritmo che utilizza BFS opportunamente e che risolve il problema.

88 Stampa del percorso minimo Stampa-percorso(G:grafo, s,v:vertice) BFS(G,s) if v = s then stampa s else if pred[v] = NIL then stampa non esiste alcun cammino tra s e v else Stampa-percorso(G,s, pred[v] ) stampa v


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

Presentazioni simili


Annunci Google