rvore Geradora

Projeto e Anlise de Algoritmos

n

Mtodo Guloso

Um rvore geradora de um grafo G um

subgrafo de G que
n

Altigran Soares da Silva

uma rvore
Contm todos os vrtices de G

Universidade Federal do Amazonas

Departamento de Cincia da Computao

rvore geradora de G

rvore geradora mnima

n

Sub-estrutura tima

Seja G = (V,E) um grafo

conexo e no dirigido
Seja uma funo de custo W:
E R que atribui um custo
a cada aresta de G

T2

AEM T

T1
n

rvore geradora: Uma rvore que conecta todos

os vrtices
rvores geradora Mnima: rvore geradora que
minimiza:

w(T ) =

w(u, v)

n
n
n

Removendo algum arco (u,v) particiona T em

T1 e T2
Como w(T ) = w(u, v) + w(T1 ) + w(T2 )
T1 uma AEM de G1=(V1,E1)
T2 uma AEM de G2=(V2,E2)

( u , v )T
3

Escolha Gulosa
n

Propriedade:
n

Escolha Gulosa (2)

Escolhas localmente timas ou gulosas

(greedy) levam uma soluo global tima

V-S

Teorema
n
n

Seja G=(V, E), e seja S V

Seja (u,v) a aresta de menor custo em G que
conecta S a V S
Ento (u,v) a alguma AEM de G

x
u

y
v

Escolha Gulosa (3)

n

Algoritmo Genrico para AEM

Prova
n Suponha (u,v) T
n Mesmo assim, u e v devem estar em T e deve haver
um caminho de u at v emT
n Seja qualquer aresta (x, y) neste caminho que cruza
de S paraV S
n Como (u,v) tem o menor custo, ento w(u,v) w(x,y)
n Assim, a rvore que inclui (x,y) no pode ter o custo
menor que rvore que inclui (u,v) e portanto ela no
mnima.

AEM(G,w)
1 A // Conter os arcos da AEM
2 enquanto A no formar uma AEM faa
3
Encontre um arco (u,v) seguro para A
4
AA{(u,v)}
5 retorne A

Arco seguro arco que garante que A:

n forma uma rvore
n inclui os arcos mnimos

Alg. Genrico para AEM (2)

Algoritmo de Prim
n

AEM2(G, w)
1
A // Conter as arestas da AEM
2
enquanto A no for uma rvore geradora faa
3.1
Faa um corte(S, V-S) em G que respeita A
3.2
Seja (u,v) a aresta mnima entre S e V-S
4
AA{(u,v)}
5 retorne A

Algoritmo baseado em vrtices

Constri uma rvore T, com um vrtice de cada
vez.
Utiliza um conjunto de vrtices que
corresponde a poro de T que j foi
computada
Rotula os vertices que esto fora deste
conjunto com
n

key[v] arco de menor custo que conecta v a um

vrtice no conjunto
key[v] = , se no existe tal arco

10

Algoritmo de Prim (2)

Algoritmo de Prim (3)

Prim(G,w,r)

Prim(G,w,r)

01
02
03
04
05
06
07
08
09
10
11

01
02
03
04
05
06
07
08
09
10
11

Q V[G] // Q vertices que formaro T

para cada u Q
key[u]
key[r] 0
[r] NIL
enquanto Q faa
u ExtriMin(Q)
para cada v Adj[u] do
se v Q e w(u,v) < key[v] ento
[v] u
key[v] w(u,v)

11

Q V[G] // Q vertices que formaro T

para cada u Q
key[u]
key[r] 0
[r] NIL
enquanto Q faa
u ExtriMin(Q)
para cada v Adj[u] do
se v Q e w(u,v) < key[v] ento
[v] u
key[v] w(u,v)

Atualiza
key[v]

12

Algoritmo de Prim (4)

Prim(G,w,r)
01
02
03
04
05
06
07
08
09
10
11

Prim: exemplo
O(V)

Q V[G] // Q vertices que formaro T

para cada u Q
O(log V)
key[u]
key[r] 0
[r] NIL
O(V) vezes
enquanto Q faa
u ExtriMin(Q)
O(1)
para cada v Adj[u] do
se v Q e w(u,v) < key[v] ento
O(E) arestas
[v] u
key[v] w(u,v)
O(log V)
13

Prim: exemplo (2)

14

Prim: exemplo (3)

15

16

Filas de Prioridade
n

Uma fila de prioridades (FP) uma ED que

mantm um conjunto S de elementos, cada um
associado a uma chave (key).
Uma FP deve suportar as seguintes operaes:
n
n

Prim: Tempo de Execuo

ConstriFP(S): Carrega a FP com os elementos de S

ExtriMin(S): retorna e remoce o elemento de S que
tem a menor chave
Atualiza(S,x,novachave): muda a chave do elemento
x

n
n

|V |.T (ExtriMin) + O (E ).T (Atualiza)

O (V lgV + E lgV) = O (E lgV )
Fila

T(ExtriMin)

T(Atualiza)

Total

array

O (V )

O (1)

O(V 2)

Heap binrio

O (lg V)

O(lg V)

O(E lgV )

Heap de Fibonacci

O(lg V)

O(1)

O(V lgV +E )

Um heap binrio pode ser usado

n
n

ConstriFP O(n)
ExtraMin e Atualiza O(lg n)
17

18

Algoritmo de Kruskal
n
n

n
n

Algoritmo de Kruskal (2)

Algoritmo baseado em arcos

Adiciona um arco de cada vez na ordem
crescente dos custos
Mantm uma floresta A.
Um arco incluido se ele conecta vrtices
de rvores distintas de A.

19

Kruskal(G,w) /* G=(V,E) */
01
02
03
04
05
06
07
08
09

A
para cada vrtice v V[G] do
Constri-Conjunto({v})
Ordenar as arestas de acordo com o custo w
para cada arco (u,v) nesta ordem faa
se Conjunto_de(u) Conjunto_de(v) ento
A A {(u,v)}
Unio(Conjunto_de(u),Conjunto_de(v))
retorne A

20

Exemplo Kruskal

Exemplo Kruskal (2)

21

Exemplo Kruskal (3)

22

Exemplo Kruskal (4)

23

24

Implementao de Conjuntos
n

Para implementar Kruskall necessrio

utilizar uma lista de dados para manter
conjuntos disjuntos de vrtices
Operaes
n
n
n

Conjuntos disjuntos como listas

n

n
n

Constri_Conjunto(x): S {x}
Unio(Si,Sj): S S {Si,Sj} {Si Sj}
Conjunto_de(x): retorna Si, tal que x Si

Cada conjunto lista de elementos identificados pelo

primeiro elemento.
Todos os elementos na lista apontam para o primeiro
elemento
Unio adiciona a lista menor lista maior
Conjunto-de: O(1), Unio(u,v): O(min{|C(u)|, C(v)})
1

25

26

Kruskal: Tempo de Execuo

n
n
n
n

Inicializao: O(V)
(E lg E) ~ (E lg V)
O(E) chamadas para Conjunto_De
Custo de unies
n

Caminhos Mnimos

Seja t(v) o nmero de vezes em que um vrtice v

movido para um novo conjunto maior
Cada vez que um vrtice movido, o novo
conjunto tem seu tamanho pelo menos dobrado: t(v)
log V
Tempo total de unio t (v) V log V

Tempo total: O(E lg V)

vV

27

28

Caminho Mnimo
n

Caminhos Mnimos

Seja um digrafo (grafo dirigido) G = (V,E) com

uma funo de custo W: E R
O custo do caminho p = v1 v2 vk

Problemas de caminho mnimo

n

k 1

w( p ) = w(vi , vi +1 )
i =1

Caminho mnimo: caminho de menor custo

Fonte nica (Destino nico). Encontrar o

caminho mnimo de um dado vrtice (fonte) para
todos os outros vrtices.
Par nico. Dados dois vrtices, achar o menor
caminho entre eles. A soluo para o problema de
fonte nica server para este problema.
Todos os Pares. Encontrar o caminho mnimo entre
todos os pares de vrtices do grafo. A soluo um
problema de programao dinmica.

29

30

Sub-estrutura tima
n

Inequao de tringulos

Teorema: os sub-caminhos de um
caminho mnimo so caminhos mnimos
Prova (cut and paste)
n

Definio
n

Teorema
n

Se algum sub-caminho no fosse mnimo, ele

poderia ser substitudo por um menor que
levaria ao caminho mnimo total.

31

d(u,v) custo cam. min. entre u e v

d(u,v) d(u,x) + d(x,v) para qq x

Prova
n

o cam. min. entre u-v no pode ser maior que

nenhum outro caminho entre u-v, em particular o
caminho que concatena os caminhos mnimos entre
u-x e x-v

32

Pesos negativos e ciclos

n

Relaxamento

Em geral, caminhos mnimos no podem ter

ciclos, pois se tivessem os custo poderia ser
reduzido removendo o ciclo.
Qualquer caminho mnimo em um grafo no
pode ter mais que n 1 arestas, onde n o nr.
de vrtices
Arestas com pesos negativos podem ser
consideradas no caminho mnimo, no entanto,
neste caso, ciclos poderiam levar a caminhos de
custo arbitrariamente menores

Para cada vrtice no grafo, mantido um valor

d[v], uma estimativa do custo total do
camin. Este valor inicializado como
Relaxar um arco (u,v) consiste em testar se
possvel melhorar o camin corrente para v
passando por u
Relax (u,v,w)
2

Relax(u,v)

5
u

if d[v]>d[u]+w(u,v)then
d[v] d[u]+w(u,v)
[v] u

Relax(u,v)

6
v

33

34

Algoritmo de Dijkstra
n
n

Dijkstra(G,w,s)

Arestas com pesos no negativos

Algoritmo guloso
n

Dijkstra
01
02
03
04
05
06
07
08
09
10
11

Similar busca em largura (BFS)

Usa uma fila de prioridade Q usando d[v]

como chave
Idia bsica
n
n

Mantm um conjunto S de vrtices j processados

A cada passo, seleciona o vrtice u mais prximo,
inclui o vrtice u, adiciona-o a S e relaxa todos os
arcos que saem de u.
35

Q : Fila de Prioridade que contm

os vrtices e tem d[v] como chave
Q = {(v1,d[v1]), (v2,d[v2]),..., (vV,d[vV])}

para cada v V
d[v]
d[s] 0
S Conjunto de vrtices j processados
Q V
enquanto Q faa
u ExtriMin(Q) Retira o u de menor d[u] de Q
S S {u}
para cada v Adj[u] faa
se d[v] > d[u]+w(u,v) ento
Relaxamento
d[v] d[u]+w(u,v)
36

Dijkstra: Exemplo
u

u
2

0
5

7
y

7
y

0
5

10

9
7

u
3

9
9

5
x

7
y
38

Dijkstra: Corretude (2)

Provar que sempre que u adicionado a S

temos d [u] = (s,u), ou seja, d mnimo, e
que isto se mantm da em diante
Prova
n
n

Dijkstra: Corretude

37

13

y
v

10

14

x
u

10

10

10

10

10

Dijkstra: Exemplo

Seja y o primeiro vrtice em V S que pertence

ao caminho mnimo verdadeiro de s at u.
Ento d [y] = (s,y), pois:
n

Temos que: v, d [v] (s,v)

Seja u o primeiro vrtice escolhido tal que existe um
caminho mais curto at u ou seja d[u] > (s,u)
Mostraremos que isso leva a uma contradio

39

Para o predecessor x de y, onde x S , d [x]

minimo, j que u o primeiro vrtice incorreto
Alm disso, quando x inserido em S, a aresta (x,y)
foi relaxada, assinalando a d[y] o valor correto.

40

Dijkstra: Corretude (3)

Dijkstra: Corretude (4)

n

Vrtice
corretamente
escolhido

Assim:
n
n
n
n

Vrtice que est no

caminho mnimo
real at u

Primeiro vrtice
escolhido tal que
d[u] no mnimo

d[u] >
>
>
d[u] >

(s,u)
(s,y)+(y,u)
d [y]+(y,u)
d [y]

* Hiptese inicial
* Sub-estrutura tima
* Corretude de d [y]
* Pesos no negativos

Mas se d [u] > d [y] o algoritmo teria escolhido

y ao invs de u da fila Q contradio
Portanto d[u] = (s,u) no momento da insero
de u em S.

41

42

Dijkstra: Tempo de Execuo

n
n
n

Dijkstra: Tempo de Execuo

Dijkstra(G,w,s)

Implementao usando um heap binrio

Extract-Min: Cada chamada O(lg V)
d[v] d[u]+w(u,v)
n Altera o Heap : O(lg V)
n No total so feitas |E | chamadas
Temos
n O(V) + O(V) + V O(lg V) + E O (lg v)
n V O(lg V) + E O (lg v) = O((V+E) lg v)
Se todos os vrtices so alcanveis da
n O(E lg v)

01
02
03
04
05
06
07
08
09
10
11
43

para cada v V
d[v]
d[s] 0
S
Q V
enquanto Q faa
u ExtriMin(Q)
S S {u}
para cada v Adj[u] faa
se d[v] > d[u]+w(u,v) ento
d[v] d[u]+w(u,v)

O(V)
O(V)
O(log V)
O(V) vezes
O(E) arestas
O(log V)

44

Algoritmo de Bellman-Ford
n

Dijkstra no funciona com arestas

negativas

Bellman-Ford(G,w,s)
01
02
03
04
05
06
07
08
09
10

No se pode assumir que o custo dos

caminhos s podem aumentar.

Bellman-Ford

O Algortimo de Bellman-Ford detecta

ciclos negativos ou retorna os caminhos
mnimos.

Relax (u,v,w)
if d[v]>d[u]+w(u,v)then
d[v] d[u]+w(u,v)
[v] u

para cada v V[G]

d[v]
d[s] 0
[r] NIL
para i 1 at |V[G]|-1 faa
para cada aresta (u,v) E[G] faa
Relax (u,v,w)
para cada aresta (u,v) E[G] faa
se d[v] > d[u] + w(u,v) ento retorne falso
retorne verdadeiro

45

46

Bellman-Ford: Exemplo

652

Bellman-Ford: Tempo

Chapter 24 Single-Source Shortest Paths

6
s 0

8
7

5
2

2
9

4 7

6
s 0

7
y

(a)

6
s 0

t
2
8

7
y
(d)

5
2

8
7

t
6

2
9

4 7

(b)
5
2

2
9

x
4
3
4 7
2
z

6
s 0

t
2
8

7
y

6
s 0

t
6

x
4
3

8
7

5
2

7
y

4 7
2
z

(c)
5
2

2
9

x
4
3
4 7
2
z

Bellman-Ford(G,w,s)
01
02
03
04
05
06
07
08
09
10

para cada v V[G]

d[v]
(|V|-1)|E| + |E| = (VE)
d[s] 0
[r] NIL
para i 1 at |V[G]|-1 faa
para cada aresta (u,v) E[G] faa
Relax (u,v,w)
para cada vrtice (u,v) E[G] faa
se d[v] > d[u] + w(u,v) ento retorne falso
retorne verdadeiro

(e)
47

48

Bellman-Ford: Corretude
n

Bellman-Ford: Corretude (2)

Provar que se o menor caminho entre s e

u tem i arestas, ento depois do i-simo
passo do algoritmo teremos o menor
caminho, ou seja, d[u]=(s,u)

Provar por induo que d[u]= i(s,u)

depois da i-sima iterao
n
n
n

Seja i(s,u) o custo do caminho de s at u

que o mnimo entre todos os caminhos
que contm no mximo i arestas

Base da induo. Inicio do algoritmo

Hiptese da induo: d[u]= i-1(s,u)
Passo indutivo
n Caso 1: i(s,u) = i-1 (s,u) => d[u]= i(s,u)
n Caso 2: i(s,u) = i-1 (s,z) + w(z,u)
n

Na iterao cada arco relaxado, inclusive

(z,u), ento d[u] = i(s,u)

49

50

Belman-Ford: Corretude (3)

n

Problema da Mochila

Se |V|=n, temos que depois de n-1 iteraes:

d[u] = n-1(s,u), para cada vrtice u.
Se ainda existe alguma aresta a relaxar no grafo,
ento ainda existe um vrtice u tal que n(s,u) <
n-1(s,u).
Mas s existem n vrtices. Portanto deve haver
um ciclo, ele deve ser negativo.
Caso contrrio d[u] = n-1(s,u) = (s,u) , para todo
u, uma vez que qualquer caminho mnimo ter n
mximo n-1 arestas.
51

necessrio preencher uma mochila com

objetos de diferentes pesos e valores. O
objetivo que se preencha a mochila
com o maior valor possvel, no
ultrapassando o peso mximo.

52