La presentazione è in caricamento. Aspetta per favore

La presentazione è in caricamento. Aspetta per favore

Algoritmi greedy Gli algoritmi greedy in genere non sono esatti, cioè determinano soluzioni non necessariamente ottime Per il problema dellalbero ricoprente.

Presentazioni simili


Presentazione sul tema: "Algoritmi greedy Gli algoritmi greedy in genere non sono esatti, cioè determinano soluzioni non necessariamente ottime Per il problema dellalbero ricoprente."— Transcript della presentazione:

1 Algoritmi greedy Gli algoritmi greedy in genere non sono esatti, cioè determinano soluzioni non necessariamente ottime Per il problema dellalbero ricoprente sono esatti Algoritmo di Prim – conserva connessione e aciclicità – tende alla ricopertura Algoritmo di Kruskal – conserva aciclicità e ricopertura – tende verso la connessione

2 Algoritmo di Prim Prim(G,c) U = {v 1 }; X = While U V do e* = (u,v) = arg min u U, v V\U c uv X = X {e*} U = U {v} Parte con un solo vertice (arbitrario) e nessun arco (sottografo connesso e aciclico, ma non ricoprente) Aggiunge ogni volta larco minimo del taglio individuato dallalbero corrente conserva connessione e aciclicità

3 Esempio di esecuzione dellalgoritmo di Prim 1 v1v1 v5v5 v2v2 v3v3 v4v U = {v 1 } X =Ø 1 v1v1 v5v5 v2v2 v3v3 v4v U = {v 1, v 2 } X = {[v 1,v 2 ]} 1 v1v1 v5v5 v2v2 v3v3 v4v v4v4 1 v1v1 v5v5 v2v2 v3v U = {v 1, v 2, v 5 } X = {[v 1,v 2 ], [v 1,v 5 ]}

4 1 v1v1 v5v5 v2v2 v3v3 v4v U = {v 1, v 2, v 3, v 5 } X = {[v 1,v 2 ], [v 1,v 5 ], [v 3,v 5 ]} costo: 9 1 v1v1 v5v5 v2v2 v3v3 v4v U = {v 1, v 2, v 3, v 4, v 5 } = V X = {[v 1,v 2 ], [v 1,v 5 ], [v 3,v 5 ], [v 4,v 5 ]} Esempio di esecuzione dellalgoritmo di Prim

5 Altre soluzioni ammissibili (di costo non inferiore) 1 v1v1 v5v5 v2v2 v3v3 v4v Esempio di esecuzione dellalgoritmo di Prim 1 v1v1 v5v5 v2v2 v3v3 v4v v1v1 v5v5 v2v2 v3v3 v4v costo: 16 costo: 11 costo: 9 Altra soluzione ottima, ottenibile cambiando lato al passo 2

6 La complessità dipende da come si determina e* Idea 1: scandire tutti i lati: O(mn) Ogni ciclo While richiede O(m) operazioni elementari (se T(U,X) è una lista di lati più un vettore di incidenza 4m + 4 operazioni) 2m per lappartenenza al taglio [v,w] (S), [v,w] A 2m per confrontare il costo minimo con c uv ed eventualmente aggiornarlo 4 per aggiornare X e U (incremento contatore, aggiunta estremi nella lista, cambio di bit nel vettore) Complessità dellalgoritmo di Prim

7 Una versione O(n 2 ) N.B.: Ad ogni passo nel taglio cambiano solo gli archi incidenti nellultimo vertice aggiunto a U Idea 2: per ogni vertice v fuori da U conservare il lato minimo incidente in v del taglio indotto da U (e il suo costo) Cmin[v] = min u U c uv (c uv = + se [i,j] E) Pred[v] = v 3 U v U v3v v5v5 Cmin[v] = 2 Pred[v] = arg min u U c uv v1v1

8 Prim2(G,c) For v = 1 to n do Uinc[v] = 0 Cmin[v] = + Pred[v] = 0 { U = {v 1 }; X = } Uinc[1] = 1 Cmin[1] = 0 For v Adj(1) do Cmin[v] = c 1v Pred[v] = 1 m = 0 … Una versione O(n 2 ) … While m < n-1 do{U V} vMin = 0 min = + For v = 2 to n do If (Uinc[v] = 0) and (Cmin[v] < min) min = Cmin[v] vMin = v Uinc[vMin] = 1{U = U {v}} For v Adj(vMin) do If (Uinc[v] = 0) and (c vvMin

9 1 Uinc = [ ] Cmin = [ ] Pred = [ ] Esecuzione della versione O(n 2 ) U = {v 1 } X = Ø 1 v1v1 v5v5 v2v2 v3v3 v4v v3v3 1 v1v1 v5v5 v2v2 v4v Prim2(G,c) For v = 1 to n do Uinc[v] = 0 Cmin[v] = + Pred[v] = 0 { U = {v 1 }; X = } Uinc[1] = 1 Cmin[1] = 0 For v Adj(1) do Cmin[v] = c 1v Pred[v] = 1 m = 0 …

10 Esecuzione della versione O(n 2 ) U = {v 1 } X = Ø … While m < n-1 do{U V} vMin = 0 min = + For v = 2 to n do If (Uinc[v] = 0) and (Cmin[v] < min) min = Cmin[v] vMin = v Uinc[vMin] = 1{U = U {v}} For v Adj(vMin) do If (Uinc[v] = 0) and (c uv < Cmin[v]) Cmin[v] = c uv Pred[v] = vMin Uinc = [ ] Cmin = [ ] Pred = [ ] v3v3 1 v1v1 v5v5 v2v2 v4v v2v2 U = {v 1,v 2 } X = {[v 1,v 2 ]} 1

11 Esecuzione della versione O(n 2 ) … While m < n-1 do{U V} vMin = 0 min = + For v = 2 to n do If (Uinc[v] = 0) and (Cmin[v] < min) min = Cmin[v] vMin = v Uinc[vMin] = 1{U = U {v}} For v Adj(vMin) do If (Uinc[v] = 0) and (c uv < Cmin[v]) Cmin[v] = c uv Pred[v] = vMin Uinc = [ ] Cmin = [ ] Pred = [ ] v4v4 1 v1v1 v5v5 v2v2 v3v U = {v 1, v 2, v 5 } X = {[v 1,v 2 ], [v 1,v 5 ]}

12 Esecuzione della versione O(n 2 ) … While m < n-1 do{U V} vMin = 0 min = + For v = 2 to n do If (Uinc[v] = 0) and (Cmin[v] < min) min = Cmin[v] vMin = v Uinc[vMin] = 1{U = U {v}} For v Adj(vMin) do If (Uinc[v] = 0) and (c uv < Cmin[v]) Cmin[v] = c uv Pred[v] = vMin Uinc = [ ] Cmin = [ ] Pred = [ ] 1 v1v1 v5v5 v2v2 v3v3 v4v U = {v 1, v 2, v 3, v 5 } X = {[v 1,v 2 ], [v 1,v 5 ], [v 3,v 5 ]}

13 Esecuzione della versione O(n 2 ) … While m < n-1 do{U V} vMin = 0 min = + For v = 2 to n do If (Uinc[v] = 0) and (Cmin[v] < min) min = Cmin[v] vMin = v Uinc[vMin] = 1{U = U {v}} For v Adj(vMin) do If (Uinc[v] = 0) and (c uv < Cmin[v]) Cmin[v] = c uv Pred[v] = vMin Uinc = [ ] Cmin = [ ] Pred = [ ] 1 v1v1 v5v5 v2v2 v3v3 v4v U = {v 1, v 2, v 3, v 4, v 5 } X = {[v 1,v 2 ], [v 1,v 5 ], [v 3,v 5 ], [v 4,v 5 ]}

14 For v = 1 to n do … For v Adj(1) do … While m < n-1 do … For v = 2 to n do … For v Adj(vMin) do … Complessità – Prim versione O(n 2 ) Linizializzazione richiede O(n) I due cicli For interni sono eseguiti n - 1 volte 2 Il primo ciclo For interno richiede O(n) 2 O(n2)O(n2) 3 3 Il secondo ciclo For interno scorre la stella uscente da vMin Lanalisi aggregata dà O(m) per linsieme delle sue esecuzioni

15 Una versione O(m log n) Loperazione più costosa è la ricerca del lato di costo minimo Idea 3: conserviamo gli O(n) lati candidati in uno heap creiamo lo heap dei lati candidati (BuildHeap): O(n) in più leggiamo direttamente lelemento minimo: O(n) anziché O(n 2 ) Aggiorniamo lo heap quando lalbero cresce di un vertice v; ogni lato incidente in v potrebbe entrare nello heap che andrebbe quindi aggiornato (Heapify): O(log n) anziché O(1) Complessivamente, esaminiamo O(m) archi

16 Correttezza dellalgoritmo di Prim Dato un albero ricoprente T, lato di diminuzione è un lato e T che, aggiunto a T, vi induce un ciclo C T {e} contenente un lato f C \ {e} di costo superiore (c e < c f ) C T e f c e < c f c(T {e}\{f}) < c(T) Se esiste un lato e di diminuzione rispetto a un albero T ricoprente, si può ridurre il costo di T scambiando il lato e con almeno un lato f di C

17 Per assurdo: lalbero T(V,X) restituito dallalgoritmo di Prim non sia ottimo, e lo sia invece T * (V,X*) v h e f U Aggiungendo e a X* ciclo C Se c e = c f allora T* {e} / {f} è ottimo perché costa come T* Se c e < c f, e è un lato di diminuzione quindi T* non è ottimo! T*T* Sia f (U) C Sicuramente c e c f Correttezza dellalgoritmo di Prim Seguiamo lesecuzione di Prim, arrestandoci al primo arco e X, ma X*


Scaricare ppt "Algoritmi greedy Gli algoritmi greedy in genere non sono esatti, cioè determinano soluzioni non necessariamente ottime Per il problema dellalbero ricoprente."

Presentazioni simili


Annunci Google