Você está na página 1de 19

SUMRIO

INTRODUO...................................................................................2
1 ALGORITMO DE KRUSKAL......................................................3
1.1 rvore Mnima de Suporte (MST)..............................................3
1.2 Utilizando o MST..........................................................................4
1.3 Problema da rvore de Ligaes Mnimas.................................4
1.4 Algoritmo........................................................................................5
1.5 Melhorias no Algoritmo................................................................6
2 ALGORITMO DE DIJKSTRA.......................................................6
2.1 Funcionamento do Algoritmo.......................................................6
3 ALGORITMO DE PRIM..............................................................11
3.1 Algoritmo......................................................................................12
3.2 Outro Algoritmo..........................................................................14
4 ALGORITMO DE BELLMAN-FORD........................................15
4.1 Algoritmo......................................................................................15
5 ALGORITMO DE FLOYD-WARSHALL...................................16
5.1 Algoritmo......................................................................................17
CONCLUSO...................................................................................18
REFERNCIAS BIBLIOGRFICAS............................................19

2
INTRODUO

Este trabalho tem como objetivo apresentar os Algoritmos de Caminhamento,


descrevendo suas caractersticas e particularidades, discutindo os processos que os
englobam, mostrar com representaes grficas o seu funcionamento e estudar os cdigos.

3
1 ALGORTMO DE KRUSKAL
Este algoritmo utiliza trs conjuntos e, t e vs. T usado para guardar as arestas da
rvore expandida. O algoritmo trabalha transformando uma floresta expandida de g em
uma nica rvore. O conjunto vs contm os conjuntos das rvores da floresta expandida.
Inicialmente vs contm todos os vrtices de g, onde cada vrtice um conjunto unitrio.
As arestas so escolhidas por ordem crescente de custo. Quando uma aresta une
duas sub-rvores da floresta expandida, estas so unidas em vs, quando no, ela
descartada, pois forma ciclo.

Fig. 1: Grafo Original

1.1 rvore Mnima de Suporte (Mst)


Mst (minimum spannig tree) ou msct - rvore geradora de peso mnimo (minimum
cost spanning tree) - uma rvore mnima de suporte (mst) de um grafo ponderado o
conjunto de arestas ligando todos os vrtices, tais que a soma dos pesos das arestas , pelo
menos, to baixa quanto a soma dos pesos de qualquer outro conjunto de arestas ligando
todos os vrtices.
Exemplo:

Fig. 2: rvore Mnima de


Suporte

4
1.2 Utilizando o Mst

Dado um grafo conexo no orientado g, com peso positivo nas arestas (e r+),
encontrar uma rvore geradora de g de peso mnimo. Para resolver este problema acima o
algoritmo de Kruskal uma das opes, temos outras opes como o Prim e o Boruvka.
O algoritmo de Kruskal guloso. Como o nome sugere, estratgia usada por esse
algoritmo consiste na escolha da melhor soluo em determinados instantes. Isto , ele faz
uma escolha tima localmente esperando que esta escolha leve a uma soluo tima global.
Por vezes conduz a uma soluo tima, mas nem sempre isso ocorre.

1.3 Problema da rvore de Ligaes Mnimas


- Descrio do Problema:
encontrar a rvore de comprimento total mnimo sobre uma rede orientada ou no
de distncia, tempos, etc.
- Algortmos de Kruskal:
.construir uma lista das arestas da rede e orden-las por ordem crescente de
distncias.
.comear por escolher a 1 aresta da lista;
.repetir 2 at todos os vrtices fazerem parte da rvore identificada;
.a rvore de ligaes mnimas constitudas pelas arestas escolhidas e tem
comprimento total igual a soma dos comprimentos das arestas;
- Casos Especiais:
- se, no ponto 3, temos arcos alternativos com igual comprimento e ao escolher ambos
formam-se ciclos, ento existem solues degeneradas;
- se existirem n conjunto de m arcos nas condies anteriores ento existiro mxn solues
timas;

Fig. 3: rvore Geradora


do Grafo Original

1.4 Algoritmo

Funo Kruskal (G=(V,E): grafo; Comprimento: E->R): conjunto de arestas


{inicializao}
Ordenar E por ordem crescente do comprimento
N

|V|

{arestas da rvore geradora mnima}

Inicializar n conjuntos, cada um com n de V


{lao guloso}
repita
e

{u,v}// a menor aresta no considerada

ucomp

achar(u)

vcomp

achar(v)

se ucomp vcomp ento


juntar (ucomp,vcomp)
T

T U {e}

at |T| = n-1
retornar T
A complexidade do algoritmo pode ser analisada:
- Ordenao das arestas;
- Inicializao dos conjuntos disjuntos;
- Gasto para achar as arestas;

6
- Gasto para juno.

1.5 Melhoras no Algoritmo


Pode-se colocar uma busca e ordenao mais eficientes, nas buscas de unio podese utilizar halving, mergesort outra dica para se utilizar na ordenao.
2 ALGORITMO DE DIJKSTRA
O algoritmo de Dijkstra o mais famoso dos algoritmos para clculo de caminho de
custo mnimo entre vrtices de um grafo e, na prtica, o mais empregado.
Escolhido um vrtice como raiz da busca, este algoritmo calcula o custo mnimo
deste vrtice para todos os demais vrtices do grafo. O algoritmo pode ser usado sobre
grafos orientados (dgrafos), ou no, e admite que todas as arestas possuem pesos no
negativos (nulo possvel). Esta restrio perfeitamente possvel no contexto de redes de
transportes, onde as arestas representam normalmente distncias ou tempos mdios de
percurso; podero existir, no entanto, aplicaes onde as arestas apresentam pesos
negativos, nestes casos o algoritmo no funcionar corretamente.
2.1 Funcionamento do Algoritmo
Assumiremos um conjunto, Chama-lo-emos PERM, que contm inicialmente
apenas o vrtice fonte (raiz da busca) s. A qualquer momento PERM contm todos os
vrtices para os quais j foram determinados os menores caminhos usando apenas vrtices
em PERM a partir de s. Para cada vrtice z fora de PERM matemos a menor distncia
dist[z] de s a z usando caminhos onde o nico vrtice que no est em PERM seja z.
necesssrio tambm armazenar o vrtice adjacente (precedente) a z neste caminho em
path[z].
Como fazer com que PERM cresa, ou seja, qual vrtice deve ser includo em
PERM a seguir? Tomamos o vrtice, entre todos os que ainda no pertencem a PERM, com
menor distncia dist. Acrescentamos ento este vrtice chamemo-lo de current, a PERM, e
recalculamos as distncias (dist) para todos os vrtices adjacentes a ele que no estejam em

7
PERM, pois pode haver um caminho menor a partir de s, passando por current, do que
aquele que havia antes de current ser agregado a PERM. Se houver um caminho mais curto
precisamos tambm atualizar path[z] de forma a indicar que current o vrtice adjacente a
z pelo novo caminho mnimo.
Vejamos o funcionamento do algoritmo sob uma outra representao:
1) Defini-se inicialmente o n de origem (raiz), neste caso s, e inclui-se este n em
PERM (Figura 1). Atribui-se zero a sua distncia (dist[s]) porque o custo de ir de s
a s obviamente 0. Todos os outros ns i tem suas distncias (dist[i]) inicializadas
com um valor bastante grande ("infinito").

Fig. 4: Representao do Algoritmo de Dijkstra


2) A partir de s consulta-se os vrtices adjacentes a ele, que no grafo G so u e x
(Figura 2). Para todos os vrtices adjacentes, que chamaremos z, calcula-se:
Se dist[z] > dist[s] + peso(s, z)
dist[z] = dist[s] + peso(s, z)

8
path[z] = s
Fim Se

Fig. 5: Representao do Algoritmo de Dijkstra


3) Dentre todos os vrtices no pertencentes a PERM escolhe-se aquele com a menor
distncia (Figura 3). Neste caso o vrtice x, pois dist[x] = 5.

Fig. 6: Representao do Algoritmo de Dijkstra


4) Ento, inclui-se x em PERM e a partir de x consulta-se os vrtices adjacentes a ele
que no esto em PERM, que no grafo G so u, v e y (Figura 4). Para todos os
vrtices adjacentes, que chamaremos z, calcula-se:
Se dist[z] > dist[x] + peso(x, z)
dist[z] = dist[x] + peso(x, z)
path[z] = x
Fim Se

Fig. 7: Representao do Algoritmo de Dijkstra


5) Dentre todos os vrtices no pertencentes a PERM escolhe-se aquele com a menor
distncia (Figura 5). Neste caso o vrtice y, pois dist[y] = 7.

Fig. 8: Representao do Algoritmo de Dijkstra


6) Inclui-se ento y em PERM e a partir de y consulta-se os vrtices adjacentes a ele
que no esto em PERM, que no grafo G apenas o vrtice v (Figura 6).
Se dist[v] > dist[y] + peso(y, v)
dist[v] = dist[y] + peso(y, v)
path[v] = y
Fim Se

10

Fig. 9: Representao do Algoritmo de Dijkstra


7) Dentre todos os vrtices no pertencentes a PERM escolhe-se aquele com a menor
distncia (Figura 7). Neste caso o vrtice u, pois dist[u] = 8.

Fig. 10: Representao do Algoritmo de Dijkstra


8) Inclui-se ento u em PERM e a partir de u consulta-se os vrtices adjacentes a ele
que no esto em PERM, que no grafo G apenas o vrtice v (Figura 8).
Se dist[v] > dist[u] + peso(u, v)
dist[v] = dist[u] + peso(u, v)
path[v] = u
Fim Se

11

Fig. 11: Representao do Algoritmo de Dijkstra


9) Dentre todos os vrtices no pertencentes a PERM escolhe-se aquele com a menor
distncia (Figura 9). Neste caso o nico vrtice restante v e dist[v] = 9.

Fig. 12: Representao do Algoritmo de Dijkstra


10) Por fim faz-se v pertencer a PERM. Neste ponto, todos os vrtices j esto em
PERM e a busca finalizada (Figura 13).

12
Fig. 13: Representao do Algoritmo de Dijkstra
3 ALGORITMO DE PRIM
A caracterstica principal do algoritmo de Kruskal que ele seleciona a melhor
arestas sem se preocupar da conexo com as arestas selecionadas antes. O resultado uma
proliferao de rvores que eventualmente se juntam para formar uma rvore.
J que sabemos que no final temos que produzir uma rvore s, por que no tentar
fazer com que uma rvore cresa naturalmente at a obteno da rvore geradora mnima?
Assim, a prxima aresta selecionada seria sempre uma que se conecta arvore que j
existe. Isso a idia do algoritmo de Prim:
No incio o conjunto B contm um vrtice arbitrrio. A cada passo, o algoritmo
considere todas as arestas que tocam B e seleciona a de menor peso. Depois, o algoritmo
acrescenta em B o vrtice ligada por essa aresta que no estava em B. O processo continua
at que B contenha todos os vrtices de G.
3.1 Algoritmo
funo Prim(G = (N,A): grafo): conjunto de arestas
T := {}
B := Um vrtice de G
Enquanto B no contm todos os vrtices
(u,v) := aresta de menor peso tal que u V - B e v B
T := T U {(u,v)}
B := B U {u}
Retornar T
Para ilustrar, consideremos o grafo da figura 14, comeando arbitrariamente pelo vrtice a:
Passo
Incio
1
2
3
4

Aresta considerada Conjunto B


{a}
(b,a)
{a,b}
(c,b)
{a,b,c}
(d,a)
{a,b,c,d}
(e,d)
{a,b,c,d,e}

13
5
6

(g,d)
(f,g)

{a,b,c,d,e,g}
{a,b,c,d,e,f,g}

Fig. 14: Grafo

A figura a seguir ilustra a progresso na composio da rvore geradora:

Fig. 15: Progresso na composio da


rvore geradora.

14

Para implementar eficientemente esse algoritmo, utiliza-se uma matriz de


adjacncia A[1..n, 1..n], onde cada elemento indica a distncia entre dois vrtices. Caso
dois vrtices no forem ligados por uma aresta o valor ser

. Para representar o conjunto

B, podemos utilizar duas tabelas de n elementos, uma indicando para cada vrtice o vrtice
de B que mais perto, uma outra que d a distncia at o vrtice de B que mais perto.
Seja mais_perto[1..n] e dist_mais_perto[1..n] essas duas tabelas, respectivamente.
Para um vrtice que j pertence a B, colocamos (-1) na entrada correspondente na tabela.
3.2 Outro Algoritmo
funo Prim(L = [1..n, 1..n]: grafo): conjunto de arestas
{Inicialmente consideramos que o vrtice 1 o nico elemento de B}
T := {}
Para i := 2 at n:
mais_perto[i] := 1
dist_mais_perto[i] := L[i,1]
Repetir n-1 vezes:
min :=
Para j := 2 at n:
Se 0 dist_mais_perto[j] < min ento
min := dist_mais_perto[j]
k := j
T := T U ((k,mais_perto[k])}
dist_mais_perto[k] := -1
Para j := 2 at n:
Se L[k,j] < dist_mais_perto[j] ento
dist_mais_perto[j] := L[k,j]
mais_perto[j] := k
Retornar T
Analisando esse algoritmo, conclui-se que ele tem um tempo de execuo em
O(n2). Qual o melhor entre esse algoritmo e o algoritmo de Kruskal? Se o grafo tem

15
muitas arestas, isto , ele tem um nmero de arestas que se aproxima de n(n-1), o tempo de
execuo com o algoritmo de Kruskal em O(n 2 lg n), portanto pior que o algoritmo de
Prim. Mas se o grafo esparso, o nmero de arestas se aproxima de n. Nesse caso, o
algoritmo de Kruskal est em O(n lg n) e o melhor. Na verdade, existem outros
algoritmos melhores no caso de grafo esparso.

4 ALGORITMO DE BELLMAN-FORD
O algoritmo de Bellman-Ford faz uso da mesma tcnica utilizada pelo algoritmo
de Dijkstra. Este algoritmo computa os caminhos mais curtos de um vrtice inicial de
origem a todos os demais, inclusive em grafos com pesos negativos. A nica restrio
que o grafo no possua nenhum circuito de peso negativo.
4.1 Algoritmo
Entrada: (1) Grafo G com pesos nas arestas; (2) Vrtice s de origem; (3) Matriz w de
pesos das arestas;
Sada: Caminho mais curto de s at todos os demais vrtices de G
para cada vrtice v V f aa
d[v]

fim para
d[s]

para i

1 at |V | - 1 faa
para cada aresta (u, v) E faa
se d[v] > d[u] + w(u, v) ento
d[v]

d[u] + w(u, v)

fim se
fim para
fim para
para cada aresta (u, v) E faa
se d[v] > d[u] + w(u, v) ento

16
retorne FALSO
fim se
fim para
retorne VERDADEIRO
Como j foi dito, se existir um circuito negativo, no poderemos garantir que os
caminhos encontrados nos grafos correspondem aos caminhos mais curtos. Ou seja, se
existirem arestas (u, v) tais que w(u, v) + d[u] < d[v], o algoritmo retorna FALSO. Esse
teste realizado pelo passo 12 do algoritmo. A complexidade de tempo do algoritmo de
Bellman-Ford

O(|E| |V|). Dessa forma, se voc precisa resolver o problema dos

caminhos mais curtos para um grafo com arestas com peso positivo, o algoritmo de
Dijkstra nos d uma soluo mais eficiente. Se todas as arestas do grafo possuem peso
igual a 1, um algoritmo de busca em largura, que ser discutido mais adiante, o mais
indicado. Por fim, para encontrar os caminhos mais curtos entre todos os vrtices de um
grafo com pesos nas arestas, vamos apresentar o algoritmo de Floyd-Warshall.
5 ALGORITMO DE FLOYD-WARSHALL
Se todas as arestas de G so no negativas, podemos usar o algoritmo de Dijkstra, o
que nos d um algoritmo de complexidade O(|V |3). Se o algoritmo contm arestas de peso
negativo, mas sem circuitos de peso negativo, podemos usar o algoritmo de Bellman-Ford,
que nos d um algoritmo com complexidade de tempo O(|V |2|E|) ou O(|V |4), no caso de
grafos densos.
Para o algoritmo de Floyd-Warshall, vamos supor que temos uma matriz de pesos
wnn, tal que a posio w(i, j) da matriz de adjacncias armazena o peso da aresta i

j.

Caso esta aresta no exista, w(i, j) = . O algoritmo de Floyd-Warshall considera os


vrtices intermedirios de um caminho mais curto P, ou seja, os vrtices de P que no so
os extremos e consiste de n iteraes, onde n o total de vrtices do grafo. Na primeira
iterao, trocamos a aresta i . j, para 1 = i, j = n, pelo caminho mais curto de i a j, exceto i
e j, que passe somente pelo vrtice 1. Esta operao executada pela comparao entre
w(i, 1) + w(1, j) e w(i, j) e selecionando o menor valor, onde w(i, j) = w0(i, j) corresponde
ao peso da aresta i . j. O resultado desta comparao chamado w1(i, j). Na segunda

17
iterao, trocamos o caminho de i a j calculado durante a primeira iterao pelo caminho
de menor peso de i a j que, desta vez, pode passar pelos vrtices 1 e 2. Este caminho
determinado pela comparao entre w1(i, 2) + w1(2, j) e w1(i, j). O menor entre esses dois
valores ser w2(i, j). Durante a k-sima iterao, computamos:
wk(i, j) = min(wk-1(i, j), wk-1(i, k) + wk-1(k, j)) (2.1)
para determinar o caminho mais curto entre i e j que passa somente pelos vrtices 1, 2,..., k.
O caminho mais curto entre cada par de vrtices ser encontrado aps a n-sima
iterao. As posies w(k) ij em cada matriz indicam o peso de caminho mais curto de i a j
que atravessa somente os vrtices {1, 2, . . . , k}. Para simplificar, o grafo da figura no
inclui os caminhos calculados a cada estgio dos algoritmos, mas estes no so difceis de
serem encontrados.
5.1 Algoritmo
Entrada: Matriz de adjacncias Ann do grafo G, contendo os pesos das arestas
Sada: Na matriz A, a distncia entre todos os pares de vrtices de G
para k

1 at n faa
para i

1 at n faa
para j

1 at n faa
w(i, j)

min(w(i, j), w(i, k) + w(k, j))

fim para
fim para
fim para
Ao final da execuo, o algoritmo encontrar os caminhos mais curtos entre todos
os pares de vrtices do grafo de entrada. Este algoritmo possui complexidade de O(|V |3).

18
CONCLUSO

De acordo com o assunto abordado, tornou-se possvel entender um pouco melhor o


funcionamento dos algoritmos de caminhamento, suas funes e a as diferenas de um
mtodo pra outro.

19

REFERNCIAS BIBLIOGRFICAS

Michel. rvores
http://www.inf.ufpr.br/~andre/Disciplinas/BSc/CI065/michel/ - Acessado
em: 30/05/04
Silva, Leonardo. Analise de Algoritmos (UCDB)
http://www.ec.ucdb.br/~marco/courses03a/aa/seminars/ - Acessado em:
30/05/04
Castro Junior, Amaury A. Implementao e Avaliao de Algoritmos
BSP/CGM para o Fecho Transitivo de Problemas Relacionados
www.dct.ufms.br/mestrado/dissertacoes/ - Acessado em: 30/05/04
Santos, Clesio S. Grafos
www.inf.ufrgs.br/~nedel/inf01203/ - Acessado em: 30/05/04
Oliveira, Denise. Teoria dos Grafos e Anlise Combinatria (UFRGS)
www.inf.ufrgs.br/~edenise/inf05512/ - Acessado em: 30/05/04
Universidade Federal da Bahia (UFBA)
http://www.im.ufba.br/mat156/ - Acessado em: 30/05/2004