Caminho Minimo, Fluxo Maximo e Arvores Geradoras

Caminhos Mais Curtos
Fluxo Máximo
Árvores Geradoras Mínimas
Túlio Toffolo – www.toffolo.com.br
Marco Antônio Carvalho – marco.opt@gmail.com
BCC402 – Aula 14
Algoritmos e Programação Avançada
Plano da Aula
•  Caminhos Mais Curtos

•  Algoritmo de Dijkstra
•  Algoritmo de Floyd
•  Fluxo Máximo
•  Algoritmo de Ford Fulkerson
•  Árvores Geradoras Mínimas

•  Algoritmo de Kruskal
•  Algoritmo de Prim
•  Otimização dos algoritmos
2
CAMINHOS
PROGRAMAÇÃO
MAIS CURTOS
DE TRIPULAÇÕES
Caminhos mais Curtos
•  Dados: grafo G=(V,A) orientado e

distância cij associada ao arco (i,j) ∈ A.
Problema: Obter o caminho mais curto entre dois nós s e t.
•  O comprimento de um caminho é igual à soma dos
comprimentos (distâncias) dos arcos que formam o caminho.
•  A distância ou comprimento de um arco pode ter diversas
interpretações
Exemplo 1: Dado um mapa rodoviário, determinar a rota mais

curta de uma cidade a outra.
4
Exemplo 2: Construção de uma estrada entre duas cidades A e K.

O grafo abaixo representa os diversos trechos possíveis e o custo
de construção de cada um. Determinar o trajeto ótimo cujo custo
de construção seja mínimo (corresponde a achar o caminho mais
curto de A a K em relação a estes custos).
B E H
6 4
2 4 4 4
8
F I
5 5 2 5
A K
C 4
4 2
7 4
2 4
D G J
Solução: A–D–G–I–K
custo = 7 + 2 + 2 + 5 = 16
5
•  Condição de existência:
Caminho de i a j contendo um circuito w:
k
j
i
Comprimento do caminho =
comprimento (i → k) +
comprimento (w) +
comprimento (k → j)‫‏‬
Qual é o comprimento do caminho mais curto de i a j se o

comprimento do circuito w é negativo?
6
Condição de existência:
não há circuitos de comprimento negativo.
A solução ótima (caminho mais curto) sempre será um

caminho elementar (sem ciclo).
7
" Caminho mais curto:

- De um nó a outro
- De um nó a todos os demais
- Entre todos os pares de nós de um grafo
8
Caminho mais curto do nó 1 a cada nó do grafo G=(V,A)‫‏‬
Hipótese: todas as distâncias cij são positivas:

cij ≥ 0, ∀(i,j) ∈ A
•  Algoritmo de Moore-Dijkstra (1957-1959)‫‏‬

π*(i) = comprimento do caminho mais curto do nó 1 ao nó i
Em especial, π*(1)=0 (distâncias positivas).
" Algoritmo com n-1 iterações
"   No início de cada iteração, o conjunto V de nós está
particionado em dois subconjuntos S e S, com o nó 1 em S.
S ∩S =φ
S ∪ S =V
9
–  Cada nó i ∈ V possui um rótulo π(i ), que verifica

a seguinte propriedade:
Se i ∈ S ⇒ π (i ) = π * (i ) π (i ) = min{π (k ) + c ki }
k ∈S
Se i ∈ S ⇒ π (i ) ≥ π * (i ) k ∈Γ i−
–  π (i ), i ∈ S , dá o valor do caminho mais curto de 1 a i sob

a restrição de que todos os nós utilizados (exceto o próprio
i ) pertençam a S.
π (a )
a
cai π (i )
π (b )
i
1 b
cbi
π (c )
cci
c
S S
10
Teorema: Seja o nó j ∈ S tal que π ( j ) = min π (i .)

i ∈S
Então π * ( j ) = π ( j ) , isto é, o comprimento do caminho
mais curto do nó 1 ao nó j é igual a π ( j ) .
Demonstração:
–  Por construção, certamente existe um caminho de 1 até j com
comprimento π(j).
–  Suponhamos que exista outro caminho de 1 a j de
comprimento menor do que π(j).
–  Dividamos este caminho em duas partes:
- P1 é a parte inicial, do nó 1 ao nó L, onde L é o primeiro nó
de S encontrado
- P2 é a parte final, do nó L ao nó j
11
–  comprimento de P1 ≥ π(L) ≥ π(j)‫‏‬

comprimento de P2 ≥ 0
Logo, o comprimento de P1 + P2 ≥ π(j).
12
PROGRAMAÇÃO
CAMINHOS MAIS CURTOS
ALGORITMO DE DIJKSTRA
DE TRIPULAÇÕES
Algoritmo de Moore-Dijkstra
Inicializar S ← {2,3,...,n},
S ← {1},
π(1)← 0,
π(j)← c1j se j∈Γ1+
+∞ caso contrário
Enquanto S ≠ ∅ faça
Selecionar j∈S tal que π(j)= mini∈S{π(i)}
S ← S – {j}
Para ∀i∈S e i∈Γj+ faça
π(i) ← min{π(i), π(j)+cji}
fim_enquanto
14
•  O algoritmo de Moore-Dijkstra constrói progressivamente

o conjunto dos nós mais próximos de 1.
•  Construção de uma arborescência com raiz em 1 que
define os caminhos mais curtos do nó 1 a cada nó do
grafo.
15
Exemplo:
4 S = {1}
4 5 S = {2,3,4,5,6}
2
2 5
7 π(1) = 0
1
1 5
2
3 π(2) = 7
1 π(3) = 1
3 6
7 π(4) = π(5) = π(6) = +∞

ITERAÇÃO 1
4
4 5 j=3
2 2 5 S = {2,4,5,6}
7
π*(1) = 0 1 π(2) = min{7, 1+5} = 6
2
1 5 3
π(5) = min{∞, 1+2} = 3
1
3 6 π(6) = min{∞, 1+7} = 8
7
π*(3) = 1
16
4 ITERAÇÃO 2
4 5
π*(5) = 3
2
2 5 j=5
7
π*(1) = 0 1 S = {2,4,6}
2
1 5 3 π(2) = min{6, 3+2} = 5
1 π(4) = min{∞, 3+5} = 8
3 6
7
π*(3) = 1
4 ITERAÇÃO 3
4 5
π*(2) = 5 π*(5) = 3
2
2 5 j=2
7 S = {4,6}
π*(1) = 0 1 2
1 5 3 π(4) = min{8, 5+4} = 8
1 π(6) = min{∞, 5+1} = 6
3 6
7
π*(3) = 1
17
4
4 5 ITERAÇÃO 4
π*(2) = 5 π*(5) = 3
2
2 5
7 j=6
π*(1) = 0 1
1 5
2 S = {4}
3
π(4) = 8
1
3 6
7
π*(3) = 1 π*(6) = 6
π*(4) = 8
4 ITERAÇÃO 5
4 5
π*(2) = 5 π*(5) = 3
2
2 5
7 j=4
π*(1) = 0
1
1 2 S={}
5 3
1
3 6
7
π*(3) = 1 π*(6) = 6
18
3 3
2 5 6
4
1 2
1 5 2 3 1
2
3 4 7
3 4
π

Iteração
nó Início 1 2 3 4 5 6
1 0 0 0 0 0 0 0
2 4 4 4 4 4 4 4
3 2 2 2 2 2 2 2
4 ∞

5 5 5 5 5 5
5 ∞

4 4 4 4 4 4
6 ∞ ∞ 7 7 7 7 7

7 ∞ ∞ 7 7 7 7 7
19
•  Número de operações (tempo): ~ n2

n-1 iterações, cada iteração busca o mínimo em uma lista com
até n-1 elementos (vetor π)‫‏‬
"   Caminho mais curto do nó 1:

→ ao nó j
→ a todos os nós
Mesma complexidade, mas critérios de parada diferentes.
"   Distâncias negativas:
3
3
Caminho mais curto de 1 a 3? 2
1 -8 Resultado do algoritmo? 3
10 Por que?
2
20
Algoritmo de Moore-Dijkstra para o caso com distâncias negativas
Inicializar S ← {2,3,...,n},
S ← {1},
π(1)← 0,
π(j)← c1j se j∈Γ1+
+∞ caso contrário
Enquanto S ≠ ∅ faça
Selecionar j∈S tal que π(j)= mini∈S{π(i)}
S ← S – {j}
Para ∀i∈Γj+ faça
Calcular π* ← π(j)+ cji
Se π* < π(i) então
S ← S ∪ {i}
π(i) ← π*
fim-se
fim-para
fim-enquanto
21
PROGRAMAÇÃO
CAMINHOS MAIS CURTOS
ALGORITMO DE FLOYD
DE TRIPULAÇÕES
•  Dados:
Grafo G=(V, A) orientado, |V | = n.
Não há circuitos negativos.
c = {cij}, j = 1,...,n, i = 1,...,n
cij ≥ 0
cii = 0
cij = +∞, (i, j ) ∉ A
Ak(i, j ) = valor do caminho mais curto de i a j podendo

usar apenas nós numerados de 1 a k como nós
intermediários.
23
A0(i, j ) = cij : caminho mais curto de i a j usando no máximo o nó

0 (que não existe) como nó intermediário (caminho
mais curto de i a j sem nós intermediários)‫‏‬
Ak(i, j ) : pode usar o nó k ou não.
Ak+1(i, j ) : pode usar o nó k+1 ou não.
A0 → A1 An(i, j ) = valor do caminho mais curto

A1 → A2 de i a j podendo usar
...
qualquer nó de 1 a n como
An-1 → An nó intermediário.
24
•  Se Ak+1(i, j ) não usa o nó k+1 como intermediário, então:
Ak+1(i, j ) = Ak(i, j )
•  Se Ak+1(i, j ) usa o nó k+1 como intermediário, então:
Ak+1(i, j ) = Ak(i, k+1) + Ak(k+1, j )‫‏‬
Ak+1(i, j ) = min { Ak(i, j ), Ak(i, k+1) + Ak(k+1, j ) }
25
Algoritmo de Floyd:
Para i = 1,...,n faça

Para j = 1,...,n faça
A0(i,j) ← cij
fim-para
fim-para
Para k = 1,...,n faça
Para j = 1,...,n faça
Ak(i,j) ← min{Ak-1(i,j),
Ak-1(i,k) + Ak-1(k,j)}
fim-para
fim-para
fim-para
26
Exemplo:
6
0 4 11 0 4 11
1 2
4 C = 6 0 2 A0 = 6 0 2
3 11 2 3 +∞ 0 3 +∞ 0
3
0 4 11 0 4 6 0 4 6
A1 = 6 0 2 A2 = 6 0 2 A3 = 5 0 2
3 7 0 3 7 0 3 7 0
Teoriade Grafos 27
•  Algoritmo de Dijkstra: número de operações (tempo) ~ n2

n-1 iterações, cada iteração busca o mínimo em uma lista com até
n-1 elementos (vetor π)‫‏‬
•  Algoritmo de Floyd: número de operações (tempo) ~ n3
Três comandos for de 1 até n um dentro do outro
•  Ou seja, o problema de calcular os caminhos mais curtos entre todos
os pares de nós pode ser resolvido com a mesma eficiência
aplicando-se n vezes o algoritmo de Dijkstra, uma vez a partir de
cada nó inicial.
28
Otimizações: uso de Heaps
Complex. Complexidade Amortizada

Operação “Real” Pairing Heap Fibonacci Heap
isEmpty O(1) O(1) O(1)
size O(1) O(1) O(1)
getMax O(1) O(1) O(1)
put O(1) O(log n) ** O(1)
removeMax O(n) O(log n) O(log n)
meld O(1) O(log n) ** O(1)
remove O(n) O(log n) O(log n)
increaseKey O(n) O(log n) ** O(1)
PROGRAMAÇÃO
FLUXO MÁXIMO
DE TRIPULAÇÕES
Problema do Fluxo Máximo
•  Dados: Grafo G=(X,U) orientado

∀u ∈ U: capacidade c(u)‫‏‬
0 ≤ f(u) ≤ c(u)‫‏‬
fonte f sumidouro
S P
•  Problema: Obter um fluxo máximo de S a P respeitando as

restrições de capacidade e as restrições de conservação de
fluxo em cada nó.
31
" Inserindo-se um arco de retorno, transforma-se um

fluxo em uma circulação :
S P
Exemplo: a capacidades c
1, 1 0, 5
fluxos f
S 1, 2 P
3, 3
2, 4
b
3, ∞

32
v, x = S
∑ f (u ) − ∑ f (u ) = 0, ∀x ≠ S, ∀x ≠ P
u I u x
: ( )= uT u x
: ( )=
-v, x ≠ P
u
I(u) T(u)
Com o arco de retorno:
∑ f (u ) − ∑ f (u ) = 0, ∀x ∈ X
uI u x
: ( )= uT u x
: ( )=
33
Exemplo:
a c
2
∞
∞

3 1
S 1 e 1 P
2 7
∞
5 ∞

b d
"   Capacidades associadas aos nós:

2 3 2 3
c(x)‫‏‬
x x1 x2
8 7 8 7
34
FLUXO MÁXIMO
ALGORITMO DE
FORD FULKERSON
"   Algoritmo de rotulação de Ford e Fulkerson (idéia básica)‫‏‬
Início: fluxo viável (por exemplo um fluxo nulo)
Iteração:
Determinar um caminho C de S a P ao longo do
qual nenhum arco esteja saturado.
(isto é, f(u) = c(u))
Circuito Γ = C ∪ {(P,S)}
Aumentar o fluxo ao longo dos arcos de Γ do
valor δ = minu∈Γ[c(u)-f(u)]
36
Exemplo: a
1
1 5
S 2 P
1
3
4
b 32
1
2
3
Este fluxo (f=3) é máximo?

Por que?
Fluxo máximo = 4
37
"   A inexistência de um caminho aumentante no grafo original

não quer dizer que não seja possível aumentar o fluxo.
•  Obter uma cadeia ligando S e P que, em conjunto com o arco de
retorno (P,S) defina um ciclo Γ:
Γ+: arcos de Γ orientados como (P,S)‫‏‬

Γ-: arcos de Γ orientados no sentido oposto a (P,S)‫‏‬
δ1= minu∈Γ+ [c(u) – f(u)] (aumento possível nos arcos de Γ+)

δ2= minu∈Γ- [f(u)] (redução possível nos arcos de Γ-)
" Melhorar a solução (aumentar o fluxo) somando

δ = min{δ1, δ2} aos fluxos nos arcos de Γ+ e subtraindo δ aos
fluxos nos arcos de Γ-.
38
f(u) c(u)
Exemplo:
a
1, 1 Γ+ 1
0, 5
X
+1
1,
X 2 Γ

- P
S 0 Γ
-1
+1
Γ+
2,
X 4
3, 3
3 b
Γ+
+1 3,
X ∞

4
δ1 = 2
δ=1
δ2 = 1
39
Algoritmo
•  Procedimento de rotulação para obter um ciclo Γ:

Nó x → rótulo δ(x)‫‏‬
Quantidade pela qual pode ser
aumentado o fluxo de S a x seguindo
uma cadeia cujo último arco é A(x)‫‏‬
u
"   Rotulação direta: x y
x marcado δ(x)‫‏‬ δ(x)

com u = (x,y)‫‏‬
f(u) < c(u)‫‏‬ δ(y) = min { δ(x), c(u)-f(u) }
y não marcado
A(y) = u
40
u
" Rotulação inversa: x y
x marcado δ(x)‫‏‬ δ(x)

arco u = (y,x)‫‏‬
δ(y) = min { δ(x), f(u) }
f(u) > 0
y não marcado
A(y) = u
f(u) ← 0 ∀u
ROTULAR(f,δ,A,Y)
Enquanto δ > 0 faça
ALTERAR_FLUXOS(f,δ,A)
ROTULAR(f,δ,A,Y)
fim-enquanto
41
ROTULAR(f,δ,A,Y)
δ, δ(S) ← +∞

Y ← {S}
Enquanto P ∉ Y e δ > 0 faça
Se ∃u =(x,y): x ∈ Y, y ∉ Y e f(u) < c(u) então
Y ← Y ∪ {y}
A(y) ← u
δ(y) ← min {δ(x), c(u)-f(u)}
Senão
Se ∃u =(y,x): x ∈ Y, y ∉ Y e f(u) > 0 então
Y ← Y ∪ {y}
A(y) ← u
δ(y) ← min {δ(x), f(u)}
Senão
δ ← 0
fim-enquanto
Se P ∈ Y então δ ← δ(P)
FIM-ROTULAR
42
ALTERAR_FLUXOS(f,δ,A)
x ← P
f(P,S) ← f(P,S) + δ

Enquanto x ≠ S faça
u ← A(x)
Se x = T(u) então
f(u) ← f(u) + δ

x ← I(u)
Senão
f(u) ← f(u) - δ

x ← T(u)
fim-enquanto
FIM-ALTERAR_FLUXOS
43
a
1, 1
Exemplo: 1,
0, 5
S 1, 2
0, P
3, 3
2,
3, 4
b
3, ∞

4,
Marcação: f(P,S) = 4
δ(S) = +∞
Y = {S} A(S) = (P,S)‫‏‬
f(a,P) = 1
δ(b) = 2 Y = {S, b} A(b) = (S,b)‫‏‬
f(a,b) = 0
δ(a) = 1 Y = {S, b, a} A(a) = (a,b)‫‏‬
f(S,b) = 3
δ(P) = 1 Y = {S, b, a, P} A(P) = (a,P)‫‏‬
f(S,a) = 1
δ=1
f(b,P) = 3
44
a
1, 1
Exemplo: 1, 5
S 0, 2 P
3, 3
3, 4
b
4, ∞

Marcação:
δ(S) = +∞
Y = {S}
δ(b) = 1 Y = {S, b}
δ = 0, P ∉ Y FIM
45
15 15
2 6
Exemplo: 15
15
20 4 15
5
1 12 5 7
8
6 8
10 8
3 4 8
9 12
15
∞

δ(1) = +∞
Y = {1} A(1) = (7,1)‫‏‬
f(6,7) = 15
δ(2) = 20 Y = {1, 2} A(2) = (1,2)‫‏‬
f(2,6) = 15
δ(6) = 15 Y = {1, 2, 6} A(6) = (2,6)‫‏‬
f(1,2) = 15
δ(7) = 15 Y = {1, 2, 6, 7} A(7) = (6,7)‫‏‬
f(7,1) = 15
δ = 15
46
15 15
2 6
Exemplo: 15
15
20 4 15
5
12 5 7
1 8
6 8 8
10 8
8
8 8
3 4 8
9 12
15
23
∞

δ(1) = +∞
Y = {1} A(1) = (7,1)‫‏‬
f(8,7) = 8
δ(3) = 10 Y = {1, 3} A(3) = (1,3)‫‏‬
f(4,8) = 8
δ(4) = 9 Y = {1, 3, 4} A(4) = (3,4)‫‏‬
f(3,4) = 8
δ(8) = 9 Y = {1, 3, 4, 8} A(8) = (4,8)‫‏‬
f(1,3) = 8
δ(7) = 8 Y = {1, 3, 4, 8, 7} A(7) = (8,7)‫‏‬
f(7,1) = 23
δ=8
47
15 15
2 6
Exemplo: 15
20
15
20 4 15
5
12 5 7
1 5 8
5 5
6 8 8
10 8
8
8 8
3 4 8
9 12
23
28
∞

δ(1) = +∞
Y = {1} A(1) = (7,1)‫‏‬
f(5,7) = 5
δ(2) = 5 Y = {1, 2} A(2) = (1,2)‫‏‬
f(3,5) = 5
δ(3) = 5 Y = {1, 2, 3} A(3) = (2,3)‫‏‬
f(2,3) = 5
δ(5) = 5 Y = {1, 2, 3, 5} A(5) = (3,5)‫‏‬
f(1,2) = 20
δ(7) = 5 Y = {1, 2, 3, 5, 7} A(7) = (5,7)‫‏‬
δ=5 f(7,1) = 28
48
15 15
2 6
Exemplo: 20
15
20 4 15
5
12 5 7
1 7
5 8
5 5
7
6 8 8
10 8
10
8
8 8
3 4 8
9 12
28
30
δ(1) = +∞
Y = {1} A(1) = (7,1)‫‏‬
f(5,7) = 7
δ(3) = 2 Y = {1, 3} A(3) = (1,3)‫‏‬
f(3,5) = 7
δ(5) = 2 Y = {1, 3, 5} A(5) = (3,5)‫‏‬
f(1,3) = 10
δ(7) = 2 Y = {1, 3, 5, 7} A(7) = (5,7)‫‏‬
δ=2 f(7,1) = 30
49
15 15
2 6
Exemplo: 20
20
15
4 15
5
12 5 7
1 7 8
5 7
6 8 8
10 8
10
8 8
3 4 8
9 12
30
∞

δ(1) = +∞
Y = {1}
δ = 0, P ∉ Y FIM
50
Teorema do Corte Mínimo
•  Um conjunto de arcos C é chamado de corte separando P de S se ∃

Y ⊂ X com S ∈ Y e P ∉ Y tal que
C = { u ∈ U: I(u) ∈ Y, T(u) ∉ Y }
•  Um corte separando P de S corta qualquer caminho de S a P no

grafo G = (X,U).
•  Capacidade de um corte separando P de S:
c(C) = ∑u∈C c(u)‫‏‬
51
" Teorema:
fluxo viável f
f(P,S) ≤ c(C)‫‏‬
corte C
Y Y
f sp = f ps + f (P , S )
fS
S
P f ps ≥ 0 ⇒ f (P , S ) ≤ f sp = ∑ f (u )
P
u C
fP
∈
≤ ∑ c (u ) = c (C )
S
u C
∈
52
•  Corolário:
Quando o algoritmo de rotulação termina com um fluxo f sem que
seja possível marcar o nó P, f é a solução ótima do problema de
fluxo máximo de S a P.
P∉Y
u T(u)‫‏‬
f(u) = c(u),
Y Y senão a extremidade u
estaria marcada
u I(u)‫‏‬ f(u) = 0,
senão a extremidade u
Y Y
estaria marcada
53
•  Corolário:
Se as capacidades são inteiras, então o algoritmo de Ford e
Fulkerson obtém em um número finito de iterações uma solução
ótima do problema de fluxo máximo.
54
•  Teorema:
O valor do fluxo máximo é igual à capacidade do corte mínimo

separando P de S.
Ao final do procedimento de rotulação:
Y Y
fSP = fPS + f*(P,S)‫‏‬
fSP fPS = 0
S
P
fSP = c(C)‫‏‬
fPS
f*(P,S) = c(C)‫‏‬
f(P,S) ≤ c(C)‫‏‬
f*(P,S)‫‏‬
corte é mínimo.
55
15 15
Exemplo: 2 6
20
20 15
4 15
5
12 5 7
1 7 8
5 7
6 8 8
10 8
10
8 8
3 4 8
9 12
30
∞

Corte mínimo
Capacidade = 30 δ(1) = +∞
Y = {1}
Fluxo máximo = 30
δ = 0, P ∉ Y FIM
56
ÁRVORES
PROGRAMAÇÃO
GERADORAS
DE TRIPULAÇÕES
MÍNIMAS
Introdução
•  Árvore Geradora Mínima – AGM

(Minimum Spanning Tree – MST)
•  Um dos problemas de otimização mais simples e mais
bem estudados em Ciência da Computação e Teoria dos
Grafos
•  Objetivos
•  Obtenção de uma árvore em um grafo conexo, com arestas
valoradas, de tal forma que a soma dos custos das arestas
seja mínimo
Principais Algoritmos
•  Algoritmo de Boruvka (1926)

O. Boruvka. O jistém problému minimálním. Práca Moravské
Prirodovedecké Spolecnosi, 3 (1926), 37-58. (In Czech.)
•  Algoritmo de Kruskal (1956)

J.B. Kruskal. On the shortest spanning tree of a graph and the
traveling salesman problem. Proceedings of the American
Mathematical Society, 7:48-50, 1956.
•  Algoritmo de Prim (1957)

R.C. Prim. Shortest connection networks and some
generalizations. Bell Systems Technology Journal, 36:1389-1401,
1957.
PROGRAMAÇÃO
ÁRVORES GERADORAS MÍNIMAS
ALGORITMO DE BORUVKA
DE TRIPULAÇÕES
Algoritmo de Boruvka
•  Primeiro algoritmo proposto para resolução do Problema

da Árvore Geradora Mínima
•  Surgiu em 1926 antes dos primeiros computadores e da
publicação do primeiro livro sobre teoria dos grafos
(1936)
•  Seu propósito era fornecer uma cobertura elétrica
eficiente para a cidade de Bohemia
•  Método ideal para implementação em computadores
paralelos
∈
•  Seja um grafo G(N, A), onde N é o conjunto de nós e A o

conjunto de arestas
Passo 1: Para cada i ∈ N faça Ni ← { i }

Passo 2: T* ← {}

Passo 3: Enquanto |T*| < (n-1) faça

Ø Para cada árvore Nk faça min(Nk, ik, jk)
Ø Para cada árvore Nk faça
Se os nós ik e jk pertencem a árvores diferentes
então unir(ik, jk) e atualizar T* ← T* ∪ {(ik, jk)}
7 21 6
14 1
4
30 10 9
PROGRAMAÇÃO
ALGORITMO DE KRUSKAL
DE TRIPULAÇÕES
Algoritmo de Kruskal
•  Idéia do algoritmo:
•  Aresta de menor peso sempre pertence à árvore
geradora de peso mínimo
•  Complexidade: O(A * log A)

•  Gargalo: ordenação das arestas
Criar uma lista L com as arestas ordenadas em

ordem crescente de pesos.
Criar |V| subárvores contendo cada uma um nó
isolado.
F ← ∅

contador ← 0
Enquanto contador < |V|-1 e L ≠ ∅ faça
Seja (u,v) o próximo arco de L.
L ← L – {(u,v)}
Se u e v não estão na mesma subárvore então
F ← F ∪ {(u,v)}
Unir as subárvores que contêm u e v.
contador ← contador + 1
fim-se
fim-enquanto
17
7
7 11
2
9
12
10
Variação do Algoritmo de Kruskal
•  Se a aresta de menor peso sempre pertence à
árvore geradora de peso mínimo, então a aresta de
maior peso não pertence, se o número de arestas
for maior que n-1
•  Complexidade: O(A*log A)
•  Gargalo: ordenação das arestas
Criar uma lista L com as arestas ordenadas em

ordem decrescente de pesos.
F ← L

contador ← 0
Enquanto contador < |A|-|V|-1 e L ≠ ∅ faça
Seja (u,v) o próximo arco de L.
L ← L – {(u,v)}
Se (u,v) não é ponte então
F ← F - {(u,v)}
fim-se
fim-enquanto
17
7
7 11
2
9
12
10
•  Principais desvantagens:
•  O método exige uma “etapa preparação”, por
exemplo, em caso de representação por listas de
adjacência
•  Grande consumo de memória
PROGRAMAÇÃO
ALGORITMO DE PRIM
DE TRIPULAÇÕES
Algoritmo de Prim
•  Inicia com uma árvore formada apenas por um nó
qualquer do grafo, ou pela aresta de peso mínimo.
•  A cada iteração, adiciona a aresta de menor peso que
conecta um nó já conectado a um nó ainda não
conectado
•  Complexidade: O(A*log N) = O(A*log A)

•  Usando Heap de Fibonacci: O(A + N*log N)
Algoritmo de Prim
Seja (u,v) a aresta de menor peso.

F ← {(u,v)}
Se c(i,u) < c(i,v) então prox(i) ← u
Senão prox(i) ← v
fim-para
prox(u), prox(v) ← 0, contador ← 0
Enquanto contador < n-2 faça
Seja j tal que prox(j)≠0 e c(j,prox(j)) é mínimo.
F ← F ∪ {(j,prox(j))}
prox(j) ← 0
Se prox(i) ≠ 0 e c(i,prox(i)) > c(i,j) então
prox(i) ← j
fim-para
fim-enquanto
Algoritmo de Prim
17
7
7
2 11
9
12
10
PROGRAMAÇÃO
OTIMIZAÇÕES
DE TRIPULAÇÕES
Implementações
•  Variação na estrutura de dados utilizada:

•  Prim usando Pairing Heap
•  Prim usando Fibonacci Heap
•  Prim usando Binary Heap
Pairing Heap x Fibonacci Heap
Complex. Complexidade Amortizada

Operação “Real” Pairing Heap Fibonacci Heap
isEmpty O(1) O(1) O(1)
size O(1) O(1) O(1)
getMax O(1) O(1) O(1)
put O(1) O(log n) ** O(1)
removeMax O(n) O(log n) O(log n)
meld O(1) O(log n) ** O(1)
remove O(n) O(log n) O(log n)
increaseKey O(n) O(log n) ** O(1)
Resultados de Moret e Shapiro (1991)
•  Grafos esparsos
1)  Binary Heap

2)  Fibonacci Heap
3)  Slay tree
4)  Rank-relaxed Heap
5)  Pairing Heap
•  Grafos com A = N * log N
1)  Binary Heap

3)  Slay tree
5)  Pairing Heap
•  Grafos com A = N3/2 (grafos densos)
1)  Binary Heap

3)  Slay tree
5)  Pairing Heap
Resultados da Literatura
•  Moret e Shapiro (1991) fazem uma série de

experimentos envolvendo vários algoritmos e estruturas
de dados para gerar uma AGM.
•  Nos testes foram utilizadas diferentes estruturas e

densidades de grafos
•  Foi feita uma análise tanto de desempenho quanto de

consumo de espaço em memória
•  Consumo de memória
•  Tempo de execução
Perguntas?
85

Caminho Minimo, Fluxo Maximo e Arvores Geradoras

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Caminho Minimo, Fluxo Maximo e Arvores Geradoras

Caricato da

Copyright:

Formati disponibili

Caminhos Mais Curtos

• Caminhos Mais Curtos

• Árvores Geradoras Mínimas

• Dados: grafo G=(V,A) orientado e

Exemplo 1: Dado um mapa rodoviário, determinar a rota mais

Exemplo 2: Construção de uma estrada entre duas cidades A e K.

Qual é o comprimento do caminho mais curto de i a j se o

A solução ótima (caminho mais curto) sempre será um

" Caminho mais curto:

Caminho mais curto do nó 1 a cada nó do grafo G=(V,A)‫‏‬

Hipótese: todas as distâncias cij são positivas:

• Algoritmo de Moore-Dijkstra (1957-1959)‫‏‬

– Cada nó i ∈ V possui um rótulo π(i ), que verifica

– π (i ), i ∈ S , dá o valor do caminho mais curto de 1 a i sob

Teorema: Seja o nó j ∈ S tal que π ( j ) = min π (i .)

– comprimento de P1 ≥ π(L) ≥ π(j)‫‏‬

• O algoritmo de Moore-Dijkstra constrói progressivamente

• Número de operações (tempo): ~ n2

" Caminho mais curto do nó 1:

" Distâncias negativas:

Algoritmo de Moore-Dijkstra para o caso com distâncias negativas

Ak(i, j ) = valor do caminho mais curto de i a j podendo

A0(i, j ) = cij : caminho mais curto de i a j usando no máximo o nó

Ak(i, j ) : pode usar o nó k ou não.

Ak+1(i, j ) : pode usar o nó k+1 ou não.

A0 → A1 An(i, j ) = valor do caminho mais curto

• Se Ak+1(i, j ) não usa o nó k+1 como intermediário, então:

• Se Ak+1(i, j ) usa o nó k+1 como intermediário, então:

Ak+1(i, j ) = Ak(i, k+1) + Ak(k+1, j )‫‏‬

Ak+1(i, j ) = min { Ak(i, j ), Ak(i, k+1) + Ak(k+1, j ) }

Para i = 1,...,n faça

• Algoritmo de Dijkstra: número de operações (tempo) ~ n2

Complex. Complexidade Amortizada

• Dados: Grafo G=(X,U) orientado

• Problema: Obter um fluxo máximo de S a P respeitando as

" Inserindo-se um arco de retorno, transforma-se um

Com o arco de retorno:

" Capacidades associadas aos nós:

" Algoritmo de rotulação de Ford e Fulkerson (idéia básica)‫‏‬

Início: fluxo viável (por exemplo um fluxo nulo)

Este fluxo (f=3) é máximo?

" A inexistência de um caminho aumentante no grafo original

Γ+: arcos de Γ orientados como (P,S)‫‏‬

δ1= minu∈Γ+ [c(u) – f(u)] (aumento possível nos arcos de Γ+)

" Melhorar a solução (aumentar o fluxo) somando

• Procedimento de rotulação para obter um ciclo Γ:

x marcado δ(x)‫‏‬ δ(x)

x marcado δ(x)‫‏‬ δ(x)

Teorema do Corte Mínimo

• Um conjunto de arcos C é chamado de corte separando P de S se ∃

• Um corte separando P de S corta qualquer caminho de S a P no

• Capacidade de um corte separando P de S:

c(C) = ∑u∈C c(u)‫‏‬

O valor do fluxo máximo é igual à capacidade do corte mínimo

• Árvore Geradora Mínima – AGM

• Algoritmo de Boruvka (1926)

• Algoritmo de Kruskal (1956)

• Algoritmo de Prim (1957)

• Primeiro algoritmo proposto para resolução do Problema

• Seja um grafo G(N, A), onde N é o conjunto de nós e A o

Passo 1: Para cada i ∈ N faça Ni ← { i }

Passo 3: Enquanto |T*| < (n-1) faça

• Complexidade: O(A * log A)

•  Caminhos Mais Curtos

•  Árvores Geradoras Mínimas

•  Dados: grafo G=(V,A) orientado e

•  Algoritmo de Moore-Dijkstra (1957-1959)‫‏‬

–  Cada nó i ∈ V possui um rótulo π(i ), que verifica

–  π (i ), i ∈ S , dá o valor do caminho mais curto de 1 a i sob

–  comprimento de P1 ≥ π(L) ≥ π(j)‫‏‬

•  O algoritmo de Moore-Dijkstra constrói progressivamente

•  Número de operações (tempo): ~ n2

"   Caminho mais curto do nó 1:

"   Distâncias negativas:

•  Se Ak+1(i, j ) não usa o nó k+1 como intermediário, então:

•  Se Ak+1(i, j ) usa o nó k+1 como intermediário, então:

•  Algoritmo de Dijkstra: número de operações (tempo) ~ n2

•  Dados: Grafo G=(X,U) orientado

•  Problema: Obter um fluxo máximo de S a P respeitando as

"   Capacidades associadas aos nós:

"   Algoritmo de rotulação de Ford e Fulkerson (idéia básica)‫‏‬

"   A inexistência de um caminho aumentante no grafo original

•  Procedimento de rotulação para obter um ciclo Γ:

•  Um conjunto de arcos C é chamado de corte separando P de S se ∃

•  Um corte separando P de S corta qualquer caminho de S a P no

•  Capacidade de um corte separando P de S:

•  Árvore Geradora Mínima – AGM

•  Algoritmo de Boruvka (1926)

•  Algoritmo de Kruskal (1956)

•  Algoritmo de Prim (1957)

•  Primeiro algoritmo proposto para resolução do Problema

•  Seja um grafo G(N, A), onde N é o conjunto de nós e A o

•  Complexidade: O(A * log A)

•  Complexidade: O(Alog N) = O(Alog A)

•  Variação na estrutura de dados utilizada:

1)  Binary Heap

•  Grafos com A = N * log N

1)  Binary Heap

•  Grafos com A = N3/2 (grafos densos)

1)  Binary Heap

•  Moret e Shapiro (1991) fazem uma série de

•  Nos testes foram utilizadas diferentes estruturas e

•  Foi feita uma análise tanto de desempenho quanto de