Caminho mais curto a partir de um nó Algoritmos de Dijkstra e Bellman-Ford. O problema tem subestrutura óptima

Transcrição

1 Caminho mais curto a partir de um nó Caminho mais curto a partir de um nó Algoritmos de Dijkstra e Bellman-Ford Fernando Lobo Algoritmos e Estrutura de Dados II Input: Um grafo com pesos nos arcos G = (V, E), w : E R e um nó de partida s. Output: Caminho mais curto de s para todos os outros nós do grafo. O peso (ou distância ou custo) de um caminho é igual ao somatório dos pesos dos arcos que constituem o caminho, ou se não existir caminho. Formalmente, seja p o caminho v 0 v k = v 0, v 1,..., v k. peso(p) = k w(v i 1, v i ) i=1 1 / 28 2 / 28 O problema tem subestrutura óptima Qualquer subcaminho de um caminho mais curto, também é um caminho mais curto. Demonstração: Por redução ao absurdo. Vamos mostrar que P xy é forçosamente um caminho mais curto de x para y. Suponhamos que existe um caminho estritamente mais curto P xy entre x e y. Isto é, peso(p xy) < peso(p xy ) Então poderíamos construir o caminho p do seguinte modo: Seja p um caminho mais curto de u para v. p passa pelos nós x e y (ver figura). peso(p) = peso(p ux ) + peso(p xy ) + peso(p yv ) peso(p ) = peso(p ux ) + peso(p xy) + peso(p yv ) < peso(p ux ) + peso(p xy ) + peso(p yv ) = peso(p) = p não é um caminho mais curto. Uma contradição. 3 / 28 4 / 28

2 Relaxamento de arcos Pseudocódigo Os algoritmos que vamos ver usam a técnica de relaxamento. Cada nó v mantém um atributo, v.d, que nos dá um limite superior do peso de um caminho mais curto de s para v. A técnica de relaxamento para um arco (u, v) consiste em testar se é possível melhorar o caminho mais curto para v passando por u, e em caso afirmativo, actualizar v.d. Relax(u, v, w) if v.d > u.d + w(u, v) v.d = u.d + w(u, v) v.π = u Ao início, o atributo v.d = para todos os nós excepto para o nó de partida s, em que s.d = 0. Initialize-Single-Source(G, s) for each v G.V v.d = v.π = nil s.d = 0 5 / 28 6 / 28 Algoritmo de Dijkstra Pseudocódigo Restrição: Os pesos não podem ser negativos. Parecido com BFS (e também com Algoritmo de Prim). Usa uma fila com prioridade em vez de uma fila FIFO. Chave (prioridade) de um nó na fila é o limite superior do custo do caminho mais curto desde o nó de origem. O algoritmo mantém dois conjuntos de nós: Dijkstra(G, w, s) Initialize-Single-Source(G, s) S = Q = G.V while Q u = Extract-Min(Q) S = S {u} for each v G.Adj[u] Relax(u, v, w) S = nós para os quais já determinamos o caminho mais curto. Q = V S (nós que ainda estão na fila). No final do algoritmo, v.d tem o peso (custo) do caminho mais curto do nó de origem s até v. Tal como no BFS, o atributo π permite-nos obter o caminho mais curto. 7 / 28 8 / 28

3 Exemplo Nó de origem é A Inicialização 1 a iteração: nó A sai da fila 9 / / 28 2 a iteração: nó C sai da fila 4 a iteração: nó B sai da fila 3 a iteração: nó E sai da fila 11 / / 28

4 Complexidade do Algoritmo de Dijkstra 5 a iteração: nó D sai da fila Inicialização: Θ(V ) Ciclo while é executado V vezes. V Extract-Mins Todos os arcos do grafo são visitados. Para cada um, há potencialmente um Decrease-Key. = Θ(V TExtract-Min + E T Decrease-Key ) Se a fila com prioridade for implementada com um heap binário (ver matéria de AED-I), obtemos: T Extract-Min = O(lg V ) TDecrease-Key = O(lg V ) 13 / / 28 Complexidade do Algoritmo de Dijkstra Algoritmo de Bellman-Ford Total = O(V lg V + E lg V ) = O ((V + E) lg V ) Igual à complexidade do Algoritmo de Prim. Consegue-se melhorar a complexidade implementando a fila com prioridade com heaps de Fibonacci. O Algoritmo de Dijkstra só funciona se todas as arestas do grafo tiverem pesos 0. Agora vamos ver um algoritmo que também funciona no caso de haver arestas com < / / 28

5 Exemplo Algumas observações Caminho mais curto não pode ter mais do que V 1 arcos. Caso contrário teria de haver forçosamente um ciclo no caminho mais curto. ciclo com peso < 0 = não existe caminho mais curto. ciclo com peso > 0 nunca pode fazer parte de um caminho mais curto. Caminho mais curto de A para D tem peso -1. A B E D O algoritmo de Dijkstra daria: A B D (com peso 1) ciclo com peso = 0 pode ser sempre removido. 17 / / 28 Algoritmo de Bellman-Ford Pseudocódigo Algoritmo de Bellman-Ford tira partido das observações anteriores. Tal como o Algoritmo de Dijkstra, também usa a técnica de relaxamento dos arcos. É conceptualmente mais simples que o Algoritmo de Dijkstra, mas a complexidade temporal é maior. Bellman-Ford(G, w, s) Initialize-Single-Source(G, s) for i = 1 to G.V 1 for each (u, v) G.E Relax(u, v, w) for each (u, v) G.E if v.d > u.d + w(u, v) return false return true Retorna true se e só se o grafo não tiver um ciclo com peso negativo que possa ser alcançado a partir do nó de origem s. Complexidade: Θ(V E) 19 / / 28

6 Exemplo de execução. Nó de origem: A Ordem pela qual o algoritmo processa os arcos: #1 (B,E) #2 (D,B) #3 (B,D) #4 (A,B) #5 (A,C) #6 (D,C) #7 (B,C) #8 (E,D) Qualquer outra ordem servia. 21 / / 28 Correcção do algoritmo A B C D E i = / A B / A C / B C i = / B E / B D / E D i = 3 i = 4 Neste caso nem era necessário fazermos a iteração i = 4 porque na iteração i = 3 já não foi possível relaxar qualquer arco. Definição: δ(s, v) é o peso de um caminho mais curto de s para v. { min{w(p) : s v} δ(s, v) = se não existir caminho de s para v Se G = (V, E) não tiver ciclos com peso negativo, então ao terminar a execução do algoritmo Bellman-Ford, v.d = δ(s, v), v V 23 / / 28

7 Demonstração Demonstração (cont.) Seja v V um qualquer nó do grafo. Consideremos um caminho mais curto p de s para v. Após a inicialização, v 0.d = 0 = δ(s, v 0 ) e nunca mais vai ser alterado. Porquê? Porque isso implicaria haver ciclos com peso negativo. Após a 1 a iteração (i = 1): v 1.d = δ(s, v 1 ) Como p é um caminho mais curto, δ(s, v i ) = δ(s, v i 1 ) + w(v i 1, v i ) Porquê? Devido à subestrutura óptima. Após a 2 a iteração (i = 2): v 2.d = δ(s, v 2 )... Após a k a iteração (i=k): v k.d = δ(s, v k ) 25 / / 28 Demonstração (cont.) Corolário Como G não tem ciclos com peso negativo, o caminho mais curto p é um caminho simples e não poderá ter mais do que V 1 arcos (daí o ciclo exterior ser executado V 1 vezes). Se no final das V 1 iterações existir algum v.d δ(s, v), então é porque existe um ciclo com peso negativo em G que pode ser alcançado a partir de s. = não existe caminho mais curto de s para v. 27 / / 28