O Problema do Passeio mais Curto

1. O Problema do Passeio mais Curto 2 23 3 9 s 18 14 6 2 6 4 19 30 11 5 15 5 6 16 20 t 7 44

2. Grafo Direcionado 2 3 1 6 4 5 8 7 • Directed graph: G = (V, E) . • V = conjunto de vértices • E  V  V= conjunto de arcos • n = |V|, m = |E|. • Caminho: s - 2 - 3 - 5 - t. • ciclo: 5 - 4 - 3 - 5.

3. Redes Rede Vértices Arcos Fluxo comunicação computadores, satélites Cabos,fibras óticas Voz,video, pacotes circuitos Processadores, Portas lógicas Fios corrente Hidraulica reservatórios, lagos dutos fluido, óleo Finanças Ações, moedas transações dinheiro

4. O Problema do Passeio Mais Curto • Rede : (V, E, s, t, c) . • Grafo Direcionado (V, E). • Fonte s  V, destino t  V. • Custo dos arcos c(v, w). • Custo do caminho = soma dos arcos do caminho Custo do caminho s - 2 - 3 - 5 - t = 9 + 23 + 2 + 16 = 48. 2 23 3 9 s 18 14 6 2 6 4 19 30 11 5 15 5 6 16 20 t 7 44

5. Passeio Mais Curto • Problema do passeio mais Curto (CLR 25.1-25.2) • Rede (V, E, s, t, c). • Encontrar o passeio mais curto de s a t. • Hipóteses: • Existe caminho de s aos demais nós do grafo • A Rede não contém ciclo com custo negativo 3 -6 -4 7 5 4

6. Caminho Mais Curto: Existencia • Existência. Se algum passeio de s a t contem um ciclo negativo, então não existe passeio mais curto entre s e v. Caso contrário, o passeio mais curto existe e é um caminho.  Se o ciclo negativo existe, é possível gerar passeios arbitrariamente negativos percorrendo o ciclo quantas vezes for necessário.  Se não existe ciclos negativos, podemos remover os ciclos sem aumentar o custo. s v C c(C) < 0

7. Propriedades importantes x P1 y s v P2 v w x • Todos os subcaminhos de um caminho mais curto são mais curtos. • P1 : subcaminho entre x e y do caminho mais curto P entre s e v. • P2 : subcaminho qualquer entre x e y • c(P1)  c(P2), caso contrário Pnão é o caminho mais curto entre s e v • Desigualdade Triangular • (v, w): comprimento do caminho mais curto de v a w. • Então, (v, w)  (v, x) + (x, w)

8. Relaxação 2 2 9 6 5 5 Relax Relax 2 2 7 6 5 5 • Técnica chave para algoritmos de caminhos mais curtos relaxation • Ideia: para todo v, manter d[v], cota superior para (s,v) Relax(u,v,w) { if (d[v] > d[u]+w) then d[v]= d[u]+w pred[v]<- u ; }

9. Algoritmo de Bellman-Ford Inicializar d[] Relaxation: execute|V|-1 iterações, relaxando cada arco Verifica a existência de Ciclos negativos • BellmanFord() • for each v  V • d[v] = ; • d[s] = 0; • for i=1 to |V|-1 • for each edge (u,v)  E • Relax(u,v, c(u,v)); • for each edge (u,v)  E • if (d[v] > d[u] + c(u,v)) • return “no solution”;

10. Algoritmo de Bellman-Ford • BellmanFord() • for each v  V • d[v] = ; • d[s] = 0; • for i=1 to |V|-1 • for each edge (u,v)  E • Relax(u,v, c(u,v)); • for each edge (u,v)  E • if (d[v] > d[u] + c(u,v)) • return “no solution”; • Relax(u,v,w): if (d[v] > d[u]+w) then d[v]= d[u]+w B -1 s 2 A E 2 3 1 -3 4 C D 5 Ex: quadro

11. Bellman-Ford: Correção • Lemma: d[v]  (s,v) ao longo da execução • Verdade no início (base da indução) • Verdade após k relaxações (hipótese indutiva) • Considere a relaxação (k+1) onde a aresta (u,v) é relaxada • Caso 1) d[v] não é modificado. Como d[v]  (s,v) antes da relaxação então d[v] (s,v) após • Caso 2) d[v] é modificado. Logo, d[v]=d[u]+c(u,v) após a relaxação. Entretanto, d[u]+c(u,v) (s,u) +c(u,v) (hipótese em u) (s,u) +c(u,v)  (s,v) (desigualdade triangular)

12. Bellman-Ford: Correção • Teorema: após |V|-1 iterações, o vetor d esta correto • Considere o caminho mais curto de s a v:s = v1  v2  v3  …  vl= v • Inicialmente d[v1] = 0 esta correto (base ) • Após k-1 iterações d[vk] estão corretos (hipótese) • Considere a iteração k (k < l ) • Quando a aresta vkvk+1 é relaxada : d[vk+1]<=d[vk]+c(vk,vk+1 ) d[vk]+c(vk,vk+1 ) = (s, vk)+c(vk,vk+1 ) (hipótese) (s, vk)+c(vk,vk+1 ) = (s, vk+1) ( mais curto)

13. Ciclos Negativos • Teorema: Se G tem um ciclo negativo o algoritmo retorna ‘no solution’ • Prova: Seja C=(v0,v1,...,vk) um ciclo negativo  c(v0,v1)+c(v1,v2)+ ... +c(vk,v0) < 0 Assuma que o agoritmo NÃO retorna ‘no solution’. Logo, d[v1] <= d[v0]+ c(v0,v1) d[v2] <= d[v1]+ c(v1,v2) • . • . • . d[v0] <= d[vk]+ c(vk,v0) Somando as equações acima obtemos c(v0,v1)+c(v1,v2)+ ... +c(vk,v0)>= 0 (Contradição)

14. Algoritmo de Dijkstra • Pesos Não Negativos

15. Algoritmo de Diksjtra for each v  V d(v)  pred(v)  nil d(s)  0 S   (utilizado na correção) Q  V for each v  V insert(v, Q) while (Q ) v vértice com menor d[] em Q Q  Q - {v} S  S  {v} (utilizado na correção) for each u  Adj[v] relax(v,u) Algoritmo de Dijkstra • Ao término • d(v) = custo do caminho mais curto entre s e v. • pred(v): predecessor no caminho mais curto

16. Algoritmo de Dijkstra f 1 d b c g g f f e ‘ a f b c 3 12 0 1 2 5 6 8 9 1 a 2 1 d 3 1 1 a 1 b 12 1 9 6 c g d 8 Update dv and pv to reflect improvement V6 is already known so ignore Update dv and pv to reflect improvement 1 5 d Enqueue Vo PQueue 2 a b 10 3 1 4 1 2 2 d c e 4 8 6 5 f g 1 No improvement to v4 so skip No improvement to v7 so skip Queue is now empty so stop No improvement to v1 so skip No improvement to v4 so skip

17. Algoritmo de Dijkstra: Correção y • Invariant. For each vertex v  S, d(v) = (s, v). • Indução em |S|. • Caso Base: Para |S| = 0 é trivial. • Passo indutivo: • Assuma que o algoritmo adicione o vértice v a S • se d(v)<> (s, v) então seja P* o caminho mais curto entre s e v • P* utiliza arco (x, y) que deixa S • Então d(v) >(s, v) hipótese =(s, x) + c(x, y) + (y, v) subcaminhos curtos (s, x) + c(x, y) custos não-negativos = d(x) +c(x, y) induçãod(y) algoritmo então Dijkstra teria selecionado y em vez de v P* x s v S

18. Priority Queues and Heaps (CLR 20, 21) Heaps Operation Linked List Binary Binomial Fibonacci * Relaxed make-heap 1 1 1 1 1 insert 1 log N log N 1 1 find-min N 1 log N 1 1 delete-min N log N log N log N log N union 1 N log N 1 1 decrease-key 1 log N log N 1 1 delete N log N log N log N log N is-empty 1 1 1 1 1 n (n) + m(1) = O(n2) n (log n) + m(1) =O(m + n log n) Dijkstra 1 make-heap n insert n delete-min m decrease-key n (log n) + m(log n) = O(m log n)

19. Shortest Path Extensions • Variants of shortest path: • Undirected graph. • O(m + n) using Thorup's algorithm • Unit weights. • O(m + n) using breadth first search • Integer weights between 0 and constant C. • DAGs. • O(m + n) using topological sort • All-pairs. • O(n3) using Floyd-Warshall

20. DAG Shortest Paths • Problem: finding shortest paths in DAG • Bellman-Ford takes O(VE) time. • How can we do better? • Idea: use topological sort • If were lucky and processes vertices on each shortest path from left to right, would be done in one pass • Every path in a dag is subsequence of topologically sorted vertex order, so processing verts in that order, we will do each path in forward order (will never relax edges out of vert before doing all edges into vert). • Thus: just one pass. What will be the running time?

21. Shortest Path: Extra Slides

22. Shortest Path: Proving Optimality • How can we verify that a given solution is really optimal? 9 32 2 23 3 9 s 0 18 14 14 6 2 6 4 19 30 45 11 5 15 5 6 34 16 20 t 7 44 50 15

23. Shortest Path: Proving Optimality • How can we verify that a given solution is really optimal? • Easy if all weights nonnegative, and there exists a zero cost path. 2 0 3 0 s 0 0 19 0 6 4 1 10 0 5 0 4 1 0 1 t 7 1