Você está na página 1de 9

Algoritmo de Dijkstra e Algoritmo de Kruskal

Karine N. Dias, Carla C. Stello UNIPAMPA Universidade Federal do Pampa Alegrete RS Brasil

Resumo. Este artigo apresenta uma reviso sobre os principais conceitos do algoritmo de Dijkstra e do algoritmo de Kruskal, no qual so algoritmos gulosos usados para solucionar o problema de caminho mais curto e busca de uma rvore geradora mnima, em um grafo, respectivamente.

1. Introduo
Em muitos problemas de interesse prtico, onde h uma sequencia de passos, e a cada passo h diversas alternativas, usa-se algoritmos relacionados com otimizao para solucionar. A tcnica que usada para resolver este tipo de problema chama-se de algoritmo guloso, ou ganancioso, no qual responsvel por fazer a deciso, em cada passo, de uma escolha considerada tima no momento, baseado simplesmente nas informaes disponveis, assim esperam que esta escolha leve at a soluo tima global. Embora algoritmos gulosos paream obviamente corretos, nem sempre seja possvel chegar a uma soluo tima. Para compensar, algoritmos gulosos so muito rpidos e eficientes. Apresenta-se neste artigo, o Algoritmo de Dijkstra, cujo um algoritmo guloso, usado para se computar o caminho mnimo em um grafo, ou seja, sua funo entenda-se que haja um grafo com peso nas arestas como fosse o comprimento -, ento se deseja atravessar do vrtice inicial ao final, ento um caminho de menor custo ser o que teremos de percorrer, uma distancia menor para chegar de um vrtice at outro. Tambm ser apresentado neste artigo, outro algoritmo guloso, o Algoritmo de Kruskal, usado para descobrir uma rvore geradora mnima em um grafo conexo e ponderado, isto significa, que sua funo encontrar um subconjunto das arestas que forma uma rvore que inclui todos os vrtices, onde o peso total, dado pela soma dos pesos das arestas da rvore, minimizado, ou seja, a ideia de Kruskal unir todas as arestas de menor peso sem formar ciclos, para encontrar a rvore geradora mnima.

2. Algoritmo de Dijkstra
O algoritmo de Dijkstra foi publicado em 1959 pelo holands, Edsger Wybe Dijkstra. Este algoritmo o mais famoso e aplicado na resoluo de problema do caminho mais curto num grafo direcionado de pesos no negativos em tempo computacional, pois caso haja presena de valores negativos, o algoritmo no garante exatido da sua soluo. O algoritmo para solucionar o problema em um grafo com pesos negativos o algoritmo de Bellman-Ford, que possui mais tempo de execuo que o Dijkstra.

Este algoritmo parte de uma estimativa inicial para o custo mnimo e vai sucessivamente ajustando esta estimativa. Ele considera que um vrtice estar fechado quando j tiver sido obtido um caminho de custo mnimo do vrtice tomado como raiz da busca at ele, ou seja, onde a soma dos pesos das arestas sejam mais baixo entre todos os caminhos possveis entre os pontos. Caso contrrio ele dito estar aberto. Para entender o funcionamento de algoritmo de Dijkstra, segue os passos: 1- Inicialmente os vrtices do grafo em estudo devem ser numerados; 2- Atribui valor aos vrtices do grafo: o vrtice de sada (raiz da busca) com o valor igual a 0 , e os demais vrtices com valor igual a ; 3- A partir do vrtice de raiz, consulta-se os vrtices adjacentes a ele. Calcula-se sua distncia entre os vrtices (soma-se o peso das arestas); 4- Dentre todos os vrtices adjacentes ao vrtice de raiz, escolhe-se aquele com a menor distncia e fecha-o. Recalcula os prximos vrtices adjacentes a ele; 5- Dentre todos os vrtices adjacentes no fechados, escolhe-se aquele com a menor distncia. Recalcula os prximos vrtices adjacentes a ele; 6- Dentre todos os vrtices no fechados, escolhe-se aquele com a menor distncia e fecha-o. 7- Por fim, escolhe-se como precedente aquele com menor distancia e fecha-o, assim a busca finalizada. Acompanha a ilustrao dos passos:

Vrtice s u x v y

Estimativas (distncia) 0

Precedentes -

Conj* Sim No No No No

*Conj = contm os vrtices para os quais j foram determinados os menores caminhos a partir do vrtice de raiz.

Figura 1. Passos 1- 2

Tabela 1. Associada a Figura 1

Vrtice s u x v y

Estimativas (distncia) 0 10 5

Precedentes s s -

Conj* Sim No No No No

*Conj = contm os vrtices para os quais j foram determinados os


menores caminhos a partir do vrtice de raiz.

Figura 2. Passo 3 kkkkkkkkkkkkkkkkkkkkkkkkkkkkk

Tabela 2. Associada a figura 2

Vrtice s u x v y

Estimativas (distncia) 0 8 5 14 7

Precedentes x s x x

Conj* Sim No SIM No No

*Conj = contm os vrtices para os quais j foram determinados os menores caminhos a partir do vrtice de raiz.

Figura 3. Passo 4 nome

meu Tabela 3. Associada a figura 3

Vrtice s u x v y Figura 4. Passo 5 algoritmo de shdddddddddddddddddddddddddddddddhhhhhh

Estimativas (distncia) 0 8 5 13 7

Precedentes x s v x

Conj* Sim No Sim No No

*Conj = contm os vrtices para os quais j foram determinados os menores caminhos a partir do vrtice de raiz.

Tabela 4. Associada a figura 4

Figuras 5 e 6. Passo 6

Vrtice s u x v y

Estimativas (distncia) 0 8 5 13

Precedentes x s v x

Conj* Sim No Sim No No

Vrtice s u x v y

Estimativas (distncia) 0 8 5

Precedentes x s v x

Conj* Sim SIM Sim No No

*Conj = contm os vrtices para os quais j foram determinados os menores caminhos a partir do vrtice de raiz.

*Conj = contm os vrtices para os quais j foram determinados os menores caminhos a partir do vrtice de raiz.

Tabela 5. Associada a figura 5 nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnTabela 6. Associada a figura 6

Vrtice s u x v y

Estimativas (distncia) 0 8 5 9

Precedentes x s u x

Conj* Sim Sim Sim SIM No

*Conj = contm os vrtices para os quais j foram determinados os menores caminhos a partir do vrtice de raiz.

Figura 7. Passo 7

Tabela 7. Associada a figura 7.

dssssssssssssssssssssssskkdnjfsdfi

Figura 8. Caminho percorrido pelo algoritmo de Dijkstra.

Pseudo-Cdigo: ALGORITMO DE DIJKSTRA // 1 passo: iniciam-se os valores: 1. para todo v V[G] 2. d[v] 3. [v] nulo 4. d[s]0 /* V[G] o conjunto de vrtices(v) que formam o Grafo G. d[v] o vetor de distncias *de s at cada v. Admitindo-se a pior estimativa possvel, o caminho infinito. *[v] identifica o vrtice de onde se origina uma conexo at v de maneira aformar um *caminho mnimo.*/ // 2 passo: temos que usar dois conjuntos: S, que representa todos os vrtices v onde d[v] j contm o custo do menor caminho e Q que contm todos os outros vrtices. //3 passo: realizamos uma srie de relaxamentos das arestas, de acordo com o cdigo: 5. enquanto Q 6. u extraia-mn(Q) 7. S S {u} 8. para cada v adjacente a u 9. se d[v] > d[u] + w(u, v) //relaxe (u, v) 10. ento d[v] d[u] + w(u, v) 11. [v]u /* w(u, v) o peso da aresta que vai de u a v. u e v so vrtices quaisquer e s o vrtice * inicial.extraia-mn(Q), pode ser um heap de mnimo ou uma lista ordenada de *vrtices onde obtm-se o menor elemento, ou qualquer estrutura do tipo.*/

Fluxograma do algoritmo de Dijkstra

3. Algoritmo de Kruskal
O algoritmo de Kruskal foi publicado em 1956. Este algoritmo tem a funo de buscar a rvore geradora mnima, isto , ele encontra um subconjunto das arestas que forma uma rvore que inclui todos os vrtices, onde o peso total, dado pela soma dos pesos das arestas da rvore, minimizado. Se o grafo no for conexo, ento ele encontra uma floresta geradora mnima (uma rvore geradora mnima para cada componente conexo do grafo). A ideia de Kruskal bastante simples: dado um grafo conexo com pesos nas arestas, a cada passo escolhemos a aresta de menos peso dentre as que ainda no esto fechadas, desde que no se forme ciclos com as arestas j escolhidas. Segue os passos de seu funcionamento: 1- Dado um grafo em questo, escolhe-se a ligao dos vrtices que possui menor peso; 2- Ordena as arestas do grafo em ordem crescente de peso; 3- Ento percorre os subgrafos vazios do grafo, adicionando a prxima aresta na lista do subgrafo atual se sua incluso no criar um ciclo fechado.

llllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll llllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll llllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll llllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll llllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll llllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll llllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll lllllllllllll

Lllllllllllllllllllllllllllllllllllllllllll

Esquema do funcionamento do algoritmo de Kruskal

Pseudo-Cdigo : KRUSKAL (G,w) 1. W 0; A ; // inicializaes /** Iniciar GA com |V| arvores com um vrtice cada*/ 2. para todo v V faa a[v] {v}; // a[v] identificado com v /** lista de arestas em ordem no decrescente de peso*/ 3. L ordene (E,w); 4. k 0; // conta arestas aceitas 5. enquanto k |V| 1 faa 6. remove (L,(u, v)); // tomar primeira aresta em L /** acha componentes de u e v*/ 7. a[u] encontrar(u); a[v] encontrar(v); 8. se a[u] a[v] ento // aceita (u, v) se no forma ciclo com A 9. A A {(u, v)}; 10. W W + w(u, v); 11. k k + 1; 12. unir (a[u], a[v]); // unir componentes 13. retorne (A,W). encontrar(u): /** retorna o apontador para o registro que representa a componente onde se encontra o vrtice u */ 1. p endereo do registro correspondente a u; 2. enquanto (p.prx nulo) faa // prx(M) : apontador ligando registros de uma mesma arvore; 3. p p.prx; 4. retorne p. unir(p,q):
/** Entrada: dois apontadores para registros correspondentes a componentes distintas de GA; * Sada: apontador para o registro correspondente ao primeiro parmetro da entrada */

1. q.prx p 2. retorne p.

4. Referncias
[1] Anderson Rocha, Leyza B. Dorini. Algoritmos gulosos: denies e aplicaes. Disponvel em: www.ic.unicamp.br/~rocha/msc/complex/algoritmosGulososFinal.pdf [2] Edson A. R. Barros, Sergio V. D. Pamboukian, Lincoln C. Zamboni. Algoritmo de Dijkstra: Apoio didtico e multidisciplinar na implementao, simulao e utilizao computacional. Disponvel em: <meusite.mackenzie.com.br/edsonbarros/publicacoes/ICECE2007_212.pdf>

[3] Algoritmo de Djikstra para clculo do Caminho de Custo Mnimo. Disponvel em: http://www.inf.ufsc.br/grafos/temas/custo-minimo/dijkstra.html
[4]Cesar k. Arruda, Flvio M. de Arajo. Servio de Roteirizao Via Web para dispositivos Mveis. Disponvel em: pt.scribd.com/doc/7773764/42/Figura-8-Pseudocodigo-do-Algoritmo-de-Dijkstra [5] Alessandro L. Koerich. Estratgia gulosa Tcnicas de projeto de Algoritmos. Disponvel em: www.ppgia.pucpr.br/~alekoe/PAA/20042/14-EstrategiaGulosaPAA2004-6T.pdf [6] Cid C. de Souza, Cndida N. da Silva. Anlise de Algoritmos. Disponvel em: www.ic.unicamp.br/~rezende/ensino/mc448/Notas-de-aula/4up-AGM.pdf