CAMINHO

Passeio ou Percurso
Um passeio uma seqncia finita de vrtices e arestas x0,a1,x1,a2,...,xk-1,ak,xk comeando e terminando com vrtices tais que xi-1 e xi so os vrtices terminais da aresta ai, 1 i k.
1

a1
6

a6 a2
4

a3 a4

a5
2

a1-a2-a3-a4-a5-a1-a6

Passeio ou Percurso
Comumente o passeio pode ser denominado passeio x0-xk, onde x0 e xk so os vrtices terminais do passeio. Um passeio dito aberto quando x0xk e fechado em caso contrrio. 1

a1
6

a2

a3
4

a4 a5

a7
3 5

a6
a1-a2-a3-a4-a5-a6-a7

Cadeias de Arestas
Uma Cadeia de Arestas ou Cadeia um passeio que no repete aresta.
1

a1 a5
6 4

a6 a4 a3
3 5

a2
2

Caminho
Um Caminho uma cadeia sem repetio de vrtices
1

a1
6

a2
4

a3 a4

a6

Comprimento do Caminho
Em um Grafo G=(N,M) , no ponderado, o comprimento de um caminho seu nmero de arestas Em um Grafo G=(N,M) , ponderado, o comprimento de um caminho a soma dos pesos de suas arestas

A C F E
Caminho de comprimento 3

D G

Ciclo / Circuito
Em um grafo G, um Ciclo um Caminho Fechado, ou seja, que inicia e termina em um mesmo n. Quando o grafo G orientado, alguns autores denominam por Circuito a seqncia de arcos distintos que repete somente o ltimo n visitado. 2 1 2 1

3 4
Grafo Ciclo C5

3 5 4 5
Grafo com circuito

Distncia entre Vrtices

Em um grafo G, a distncia d(a,b) entre os vrtices a e b de G dada pelo comprimento do menor caminho de a a b. Obs 1. Se b no alcanvel a partir de a, ento d(a,b) = Obs 2. Podem existir ciclos negativos no grafo G. Neste caso um percurso entre a e b pode ter comprimentos cada vez menores quando se passar pelo ciclo. Neste caso, deve-se ater definio de caminho (sem repetio de vrtices).

Caminho Mais Curto

Arestas de Peso Negativo
Se o grafo G no contm ciclo de peso negativo, a partir da origem s, ento para todo vrtice v V, o comprimento do caminho mais curto (s,v) permanece bem definido, mesmo tendo peso negativo. Contudo, se existe um ciclo de peso negativo a partir de s, os pesos de caminhos mais curtos no so bem definidos, pois sempre possvel encontrar um caminho ainda mais curto percorrendo o ciclo de peso negativo.

Caminho Mais Curto

Um caminho mais curto pode conter um ciclo? ?

Caminho Mais Curto

No

Caminho Mais Curto

1. De um n fonte para todos os demais vrtices 2. De todos os ns para um destino nico 3. De par nico 4. Dentre todos os pares de vrtices

Grafo no Ponderado
O caminho mais curto entre os vrtices i e j de um grafo G no ponderado pode ser calculado em O(m) pelo algoritmo de Busca em Largura.

Busca em Largura
Desmarcar todos os vrtices Definir uma fila Q Definir uma raiz s V marcar s inserir s em Q Enquanto Q { } faa seja v o primeiro elemento de Q para w A(v) faa se w no marcado ento visitar (v,w) marcar w inserir w em Q seno se w Q ento visitar (v,w) retirar v de Q

(I)

(II)

Busca em Largura

f g d e c b i a s h e b c

Grafo

rvore de Largura

BL Caminho mais Curto

Definir uma fila Q e uma origem o d(o) 0 Inserir o em Q Enquanto Q { } faa Remova v o primeiro elemento de Q para w A(v) faa se d(w) est indefinido d(w) d(v) + 1 inserir w em Q

Busca em Largura

f g 1 d e c b i i a s h g 2 b 2 s

a 1 d 1 c

2 e

2 h

3 f

Grafo

Caminho mais curto a partir do vrtice a

Caminho Mais Curto

O caminho mais curto entre os vrtices i e j de um certo grafo G ponderado aquele que acumula o menor
valor possvel dentre todos os caminhos existentes entre i e j v v 1 1 1 3 2 2 3 2 2 1 1 1 G 4 1 1 2 4 w 2 1 3 2 4 1 1 2 3 2 1 1 1
Caminho v-w

1 2

4 w

Algoritmo Dijkstra
Dijkstra (G=(N,M,P) ) d1 = 0; rot (1) = // fonte = 1 F := {1} A = N \ {1} para j = 2 at n faa se j +(1) ento dj = p1j ; rot [j] = 1 seno dj = ; rot [j] = 0 Enquanto A faa i min {dj | j A} A = A \ {i} ; F = F {i} para todo ( j +(i ) e ( j A) faa se dj > (di + pij ) ento dj = di + pij ; rot [j] = i

Algoritmo Dijkstra

2 2
0 2

2 4 1 3 4 7 1 7 6 5 5

1 4

5 3

r=1

Algoritmo Dijkstra
1 r=2 2 2 1
0 2

2 1 4 1 3 4 4 3 7 5 2 1 6

5 5 7

1 4 1

Algoritmo Dijkstra
1 2 2 1
0 2

2 1 5 2 4 r=4 3 4 4 7 6

5 1 7 5

1 4 1

5 1 3

Algoritmo Dijkstra
1 2 2 1
0 2

2 2 4 1 4 4 3 4 2

4 6

5 1 7 7 4 7 5

5 4 r=3 3 1

Algoritmo Dijkstra
1 2 2 1
0 2

2 2 4 1 3 4 4 3 4 2

4 6 1

6 r=6 5 5 7 7

1 4 1

Algoritmo Dijkstra
1 2 2 1
0 2

2 2 4 1 3 4 4 3 4 2

4 6

5 1 7 4 7 r=7 7 5 6 11

1 4 1

Algoritmo Dijkstra
1 2 2 1
0 2

2 2 4 1 3 4 4 3 4 2

4 6

5 1 7 7 4 7 5 r=5 6 11

1 4 1

Algoritmo Dijkstra
Teorema 3.1 O algoritmo de Dijkstra encontra o caminho mais curto de um vrtice fonte aos demais vrtices do grafo.

Prova: A demonstrao de que o algoritmo de Dijkstra est correto ser feita por induo em F, considerando que se o n i est em F, ento d[i] o caminho mais curto da fonte at o n i.

Algoritmo Dijkstra
Base da Induo: No incio F s contm o n 1 (fonte) e o teorema vale trivialmente. Hiptese da Induo: A hiptese vale para todos os ns de F at imediatamente antes da insero de um n i.

Algoritmo Dijkstra
Passo da Induo: Se o n i foi escolhido pelo algoritmo, ento dt[i] mnimo dentre todos os ns em A. Deve-se mostrar que dt[i] o comprimento do menor caminho entre o n origem e i.

Algoritmo Dijkstra
Passo da Induo: Supondo o contrrio, ou seja, que existe pelo menos um n x no menor caminho entre a origem e i, que no pertence ao caminho atual de comprimento dt[i], tal que dt[x] < dt[i] e x est em A. Nesse caso, o algoritmo deveria ter escolhido x ao invs de i. Mas o algoritmo escolheu i, significando que este n x no existe. Portanto, quando i adicionado a F o caminho mais curto da origem a i foi encontrado.

Algoritmo Dijkstra
Anlise de Complexidade do Algoritmo de Dijkstra Aps a inicializao, o algoritmo de Dijkstra executa dois tipos de ao em cada uma das suas iteraes: (1) Determina o prximo vrtice a ser examinado (2) Atualiza os rtulos dos vrtices que se ligam ao vrtice correntemente examinado

Algoritmo Dijkstra
Para que F contenha todos os vrtices do grafo, so necessrias n-1 iteraes do enquanto. Sem utilizar estruturas de dados especiais, as aes do tipo (1), utilizando uma busca em lista linear, devem percorrer todos os vrtices do conjunto A no pior caso, consumindo O(n) comparaes. As aes do tipo (2) podem envolver a atualizao de O(n) vrtices. Assim, uma implementao simples do o algoritmo de Dijkstra teria uma complexidade O(n2).

Algoritmo Dijkstra
Como o algoritmo emprega um critrio guloso para fechar a cada iterao o vrtice aberto e de menor caminho acumulado, torna-se incapaz de calcular o caminho mais curto em grafos com arestas de custo negativo. O algoritmo pode ser utilizado para encontrar o caminho mais curto entre todos os pares de vrtices do grafo desde que seja executado uma vez para cada vrtice como origem. Nessa situao a complexidade do mtodo seria multiplicada por n, tornando-se O(n3) na implementao sem estruturas de dados especiais.

Evoluo Algoritmo Dijkstra

Ano Autores Complexidade

1987 1990 1996 1997 1999 2000 2000

Fredman e Tarjan Ahuja et al. Raman Raman Thorup Hagerup Thorup

O (m + n log n ) O (m + n log c )
O ( m + n log n )

O (m + n(log c log log c)1 / 3 ) O (m ) - grafo no direcionado O (m log log c ) O (m log log n )

Algoritmo Bellman-Ford
O Algoritmo de Dijkstra no pode ser utilizado para grafos com arestas negativas. Algoritmo de Bellman-Ford permite arestas de peso negativo. Se existir ciclo negativo, o algoritmo detecta.

Desigualdade Triangular Para qualquer aresta (u,v) E, temos (s,v) (s,u) + w(u,v) onde (u,v) caminho mais curto de u para v w(u,v) peso da aresta (u,v)

Algoritmo Bellman-Ford
Dados G=(V,E), s e w Para cada v V faa d(v) rot(v) NIL //predecessor d(s) 0 Para i 1 at |V|-1 faa para cada aresta (u,v) faa se d(v) > d (u) + w(u,v) ento d(v) d (u) + w(u,v) rot(v) u Para cada aresta (u,v) faa se d(v) > d (u) + w(u,v) ento retorne(Falso) Retorne(verdadeiro)

Algoritmo Bellman-Ford
Exemplo 1. -2 t d(s)=0 6 s 7 y 2 8 9 5 -3 -4 z x 7 t x y z d(v) rot(v) NIL NIL NIL NIL

Algoritmo Bellman-Ford
Exemplo 1. -2 t 6 s 7b
a g e d

d(v) x 7 t x y z 6 4 7 2

rot(v) s y s t

-3 -4 9
h i

y 2

Algoritmo Bellman-Ford
Exemplo 1. -2 t 6 s 7b
a g e d

d(v) x 7 t x y z 2 4 7 -2

rot(v) x y s t

-3 -4 9
h i

y 2

Algoritmo Bellman-Ford
Exemplo 2. d(v) t 3 s -10 z z NIL
a d

rot(v) NIL NIL

8
c

t y

-3

Algoritmo Bellman-Ford
Exemplo 2. d(v) t 3 s -10 z z 8 y
a d

rot(v) z t

8
c

t y

-2 11

-3

Algoritmo Bellman-Ford
Exemplo 2. d(v) t 3 s -10 z d(y) > d(t) + w(t,y) 6 > -7 + 8 z 3 y
a d

rot(v) z t

8
c

t y

-7 6

-3

Algoritmo Bellman-Ford
Teorema 3.1 Se G no possuir ciclo de peso negativo, ento o algoritmo de Bellman-Ford retorna verdadeiro para todos os vrtices v V e encontra o caminho mais curto de uma fonte s a todos os vrtices de G. Se G possuir um ciclo de peso negativo o algoritmo retorna Falso Prova: Cormen, Leiserson, Rivest e Stein pp.467-468.

Algoritmo de Floyd-Warshall

O caminho desenvolvido de i para j passando pelo vrtice k Tcnica Programao Dinmica

Algoritmo de Floyd-Warshall
Ca min ho _ mais _ curto ( G ( N , A, D) ) L = D { L = [lij ] } Para k = 1 at n fazer Para i = 1 at n fazer Para j = 1 at n fazer lij = min(lij ; lik + lkj ) ( n )
3

Algoritmo de Floyd-Warshall

2 1 1 3 3 1

2 3 2

5 3 -3 2 4 6

Algoritmo de Floyd-Warshall
1 1 2 3 4 5 6 1 3 2 1 1 3 2 3 3 1 2 4 3 2 -3 2 5 2 -3 3 6 2 3

Matriz D

Algoritmo de Floyd-Warshall
k = 1 passando pelo vrtice 1 lij = min { lij ; (li1 + l1 j ) }
1

1 1 3

2 1 1 3 2

3 3 1 2

4 3 2 -3 2

5 2 -3 3

6 2 3

k = 1; i = 1; j = 1...6 l11 = min { l11 ; ( l11 + l11 ) } = l12 = min{ l12 ; ( l11 + l12 ) } = l12 = 1 l13 = min{ l13 ; ( l11 + l13 ) } = l13 = 3 ................................................... l16 = min{ l16 ; ( l11 + l16 ) } =

2 3 4 5 6

Algoritmo de Floyd-Warshall
k = 1; i = 2; j = 1...6 (2 para j, passando por 1) l21 = min { l21 ; (l21 + l11 ) } = 1 l22 = min{ l22 ; (l21 + l12 ) } = 2 l23 = min{ l23 ; (l21 + l13 ) } = l23 = 1 l24 = min{ l24 ; (l21 + l14 ) } = l24 = 3 l25 = min{ l25 ; (l21 + l15 ) } = l25 = 2 l26 = min{ l26 ; (l21 + l16 ) } =
1 2 3 4 5 6 1 1 3 2 1 1 3 2 3 3 1 2 4 3 2 -3 2 5 2 -3 3 6 2 3

Algoritmo de Floyd-Warshall
k = 1; i = 3; j = 1...6 l31 = min { l31 ; (l31 + l11 ) } = 3 l32 = min{ l32 ; (l31 + l12 ) } = 1 l33 = min{ l33 ; (l31 + l13 ) } = (l31 + l13 ) = 6 l34 = min{ l34 ; (l31 + l14 ) } = l34 = 2 l35 = min{ l35 ; (l31 + l15 ) } = l36 = min{ l36 ; (l31 + l16 ) } =

Algoritmo de Floyd-Warshall
k = 1; i = 4; j = 1...6 l41 = min { l41 ; (l41 + l11 ) } = l42 = min{ l42 ; (l41 + l12 ) } = 3 l43 = min{ l43 ; (l41 + l13 ) } = 2 l44 = min{ l44 ; (l41 + l14 ) } = l45 = min{ l45 ; (l41 + l15 ) } = 3 l46 = min{ l46 ; (l41 + l16 ) } = 2

Algoritmo de Floyd-Warshall
k = 1; i = 5; j = 1...6 l51 = min { l51 ; (l51 + l11 ) } = l52 = min{ l52 ; (l51 + l12 ) } = 2 l53 = min{ l53 ; (l51 + l13 ) } = l54 = min{ l54 ; (l51 + l14 ) } = 3 l55 = min{ l55 ; (l51 + l15 ) } = l56 = min{ l56 ; (l51 + l16 ) } = 3

Algoritmo de Floyd-Warshall
1 1 2 3 4 5 6 1 3 2 1 2 1 3 2 3 3 1 6 2 4 3 2 -3 2 5 2 -3 3 6 2 3

Matriz L

Algoritmo de Floyd-Warshall
k = 2; i = 1; j = 1...6 l11 = min { l11 ; (l12 + l21 ) } = 2 l12 = min{ l12 ; (l12 + l22 ) } = l12 = 1 l13 = min{ l13 ; (l12 + l23 ) } = (l12 + l23 ) = 2 l14 = min{ l14 ; (l12 + l24 ) } = (l12 + l24 ) = 4 l15 = min{ l15 ; (l12 + l25 ) } = ( l12 + l25 ) = 3 l16 = min{ l16 ; (l12 + l26 ) } =

Algoritmo de Floyd-Warshall
k = 2; i = 2; j = 1...6 l21 = min { l21 ; (l22 + l21 ) } = 1 l22 = min{ l22 ; (l22 + l22 ) } = l22 = 2 l23 = min{ l23 ; (l22 + l23 ) } = l23 = 1 l24 = min{ l24 ; (l22 + l24 ) } = l24 = 3 l25 = min{ l25 ; (l22 + l25 ) } = l25 = 2 l26 = min{ l26 ; (l22 + l26 ) } =

Algoritmo de Floyd-Warshall
1 1 2 3 4 5 6 2 1 3 2 1 2 1 3 2 3 2 1 6 2 4 4 3 2 -3 2 5 3 2 -3 3 6 2 3

Matriz L

Algoritmo de Floyd-Warshall
1 1 2 3 4 5 6 3 2 1 3 1
Matriz L

4 3 2 -3

5 2 3

6 2

Algoritmo de Floyd-Warshall
1 1 2 3 4 5 6 3 2 1 4 3 1 4 3 2 -3 5 2 3 6 2

Matriz L para k = 1

Algoritmo de Floyd-Warshall
1 1 2 3 4 5 6 3 2 1 4 3 2 1 5 4 4 3 2 -3 5 3 2 6 3 6 2

Matriz L para k = 2

Algoritmo de Floyd-Warshall
1 1 2 3 4 5 6 5 4 3 2 1 5 4 3 2 1 5 4 4 3 2 -3 5 3 2 6 3 6 2
1 2 3 4 5 6 1 5 4 3 2 1 5 4 3 2 1 5 4 4 3 2 -3 5 3 2 6 3 6 6 5 4 2 -1

Matriz L para k = 3

Matriz L para k = 4

Algoritmo de Floyd-Warshall
1 1 2 3 4 5 6 5 4 3 2 1 5 4 3 2 1 5 4 0 -1 2 -3 0 5 3 2 6 3 6 2 1 4 2 -1 2 1 2 3 4 5 6 1 5 4 3 2 1 5 4 3 2 1 5 4 0 -1 2 2 -3 0 5 3 2 6 5 2 3 6 2 1 4 2 -1 2

Matriz L para k = 5

Matriz L para k = 6

Grafo Euleriano
Cadeia Euleriana Uma cadeia em um grafo G tal que toda aresta visitada exatamente uma vez. Teorema de Euler. Considere G um (multi)grafo conexo, ento as seguintes afirmaes so equivalentes: 1. G euleriano 2. Todo vrtice de G tem grau par 3. O conjunto de arestas de G pode ser particionado em ciclos.

Grafo Euleriano
Corolrio Considere G um (multi)grafo conexo com exatamente 2k vrtices de grau mpar. Ento G contm uma cadeia euleriana se e somente se k = 0 ou k = 1.

Algoritmo de Hierholzer (1873)

Ler os dados de G=(N,M) 1. Escolher um vrtice v de G 2. Construir uma cadeia fechada C, a partir de v, percorrendo as arestas de G de forma aleatria. 3. Remover de G as arestas de C 4. Enquanto M Fazer 5. Escolher v tal que d(v) > 0 e v C 6. Construir uma cadeia fechada H, a partir de v, percorrendo as arestas de G de forma aleatria. 5. Remover de G as arestas de H 6. CHC 7. H 8. Fim_Enquanto 9. Imprimir C

Algoritmo de Hierholzer
c g d e f

Algoritmo de Hierholzer
c g d e f

Algoritmo de Hierholzer
c g d e f

Algoritmo de Hierholzer

b e f

c g

Algoritmo de Hierholzer
a c g d e f

Algoritmo de Hierholzer
Unio dos Ciclos a

b e f

c g

Algoritmo de Hierholzer
b e f

Algoritmo de Hierholzer
b e f

Algoritmo de Hierholzer
c g d e f

Algoritmo de Hierholzer
Trabalho: (24/04) 1. Faa uma implementao do Algoritmo de Hierholzer em O(m) 2. Relatrio explicando as estruturas de dados utilizadas e o clculo da complexidade. Dica: Utilize listas duplamente encadeadas

Algoritmo de Fleury (1883)

Regra da Ponte Se uma aresta (v,w) uma ponte no grafo induzido pelas arestas no marcadas, ento (v,w) s deve ser escolhida pelo algoritmo caso no haja qualquer outra opo.

Algoritmo de Fleury
Ler os dados de G=(N,M) 1. Escolher um vrtice v qualquer de G; C {v} 2. Repita 3. Escolher aresta (v,w) no marcada utilizando a regra da ponte 4. Atravessar (v,w) 5. C C {w} 6. Marcar (v,w) 7. vw 8. At que todas as arestas estejam marcadas 9. C C {v} 10. Imprimir C

Algoritmo de Fleury

c g

Algoritmo de Fleury
a b c g d a e b f c g d e f

Algoritmo de Fleury
a b c g d e a f b c g d e f

Algoritmo de Fleury
a b c g d e a f b c g d e f

Algoritmo de Fleury
a b c g d e f a b c

Algoritmo de Fleury

c g

Algoritmo de Fleury

c g

Algoritmo de Fleury
Em cada iterao do lao principal, uma aresta marcada, portanto so realizadas m iteraes do lao principal. Em cada uma destas iteraes necessrio testar a condio de ponte da aresta escolhida. Utilizando um algoritmo de percurso em grafos, esta verificao pode ser feita em O(m). O algoritmo de Fleury, neste caso, ter complexidade O(m2). Thorup (2000) apresentou um algoritmo que verifica se uma aresta uma ponte em O e atualiza uma estrutura auxiliar em O(log n(log2n)3). Portanto, com a verificao proposta por Thorup (2000) o algoritmo de Fleury pode ser implementado em O(m log n(log2n)3). Thorup, M. (2000) Near-optimal fully-dynamic graph connectivity, In: Proceedings of the 32nd ACM Symposium on Theory of Computing (STOC00), 343350.

Caminho e Ciclo mais Longo

Ciclo mais longo Dado um grafo ponderado G e um nmero positivo c, existe um caminho em G de comprimento maior ou igual a c? Problema NP-completo (Garey e Johnson, 1979). Caminho mais longo Dado um grafo ponderado G, vrtices s e t e um nmero positivo c, existe um caminho em G entre s e t com comprimento maior ou igual a c? Problema NP-completo

Caminho e Ciclo Hamiltoniano

Caminho Hamiltoniano Dado um grafo G, existe um caminho que passa por todos os vrtices de G exatamente uma vez? Problema NP-completo (Garey e Johnson, 1979). Caminho Hamiltoniano Dado um grafo G, existe um ciclo que passa por todos os vrtices de G exatamente uma vez? Problema NP-completo (Karp, 1972).

Ciclo Hamiltoniano
Teorema de Dirac Se G um grafo simples com n 3 e (G) n/2, ento G Hamiltoniano. Teorema de Ore Se d(u) + d(v) n para todo par de vrtices u, v de G, ento G Hamiltoniano.