O Problema do Passeio mais Curto 2 23 3 9 demo: microsoft streets and trips s 18 14 2 6 6 30 4 19 5 11 15 5 6 20 16 t 7 44

Grafo Direcionado 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. 1 3 8 2 6 7 4 5

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

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 2 6 6 30 4 19 11 5 15 5 6 20 16 t 7 44

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

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

Propriedades importantes 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 P nã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) s v P2 P1 y x v w x

Relaxação 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 5 2 7 Relax 6 5 2 Relax

Algoritmo de Bellman-Ford 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)); if (d[v] > d[u] + c(u,v)) return “no solution”; Inicializar d[] Relaxation: execute|V|-1 iterações, relaxando cada arco Verifica a existência de Ciclos negativos

Algoritmo de Bellman-Ford 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)); 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 s -1 2 A E 2 3 1 -3 4 C D 5 Ex: quadro

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)

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)

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)

Algoritmo de Dijkstra Pesos Não Negativos

Algoritmo de Diksjtra Ao término d(v) = custo do caminho mais curto entre s e v. pred(v): predecessor no caminho mais curto for each v  V d(v)   pred(v)  nil d(s)  0 S   (utilizado na correção) Q  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

Algoritmo de Dijkstra PQueue Enqueue Vo c 1 Enqueue Vo 1 a 1 g 1 8 c f Update dv and pv to reflect improvement ‘ V6 is already known so ignore f 6 Update dv and pv to reflect improvement g e 12 b 1 d 1 a b 1 b 2 a 1 f c 3 d g 5 d f 9 d 2 a b 10 3 1 4 1 2 2 c d e 4 8 5 6 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

Algoritmo de Dijkstra: Correção 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 y P* x s v S note d() are values just before v is added to S in algorithm

Priority Queues and Heaps (CLR 20, 21) 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 Brodal gives variant of relaxed heap that achieves worst-case bounds for all operations relaxed heap: relaxes heap ordering property 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)

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

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?

Shortest Path: Extra Slides demo: microsoft streets and trips

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

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 3 s 19 6 10 4 1 5 4 1 1 t 7 1