You are on page 1of 19

MO417 — Complexidade de Algoritmos I

Cid Carvalho de Souza Cândida Nunes da Silva


Árvore Geradora Mı́nima
Orlando Lee

16 de outubro de 2008

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1

Árvore Geradora Mı́nima Árvore Geradora Mı́nima

Suponha que queremos resolver o seguinte problema:


dado um conjunto de computadores, onde cada par de Nessa modelagem, o problema que queremos resolver é
computadores pode ser ligado usando uma quantidade de encontrar um subgrafo gerador (que contém todos os
fibra ótica, encontrar uma rede interconectando-os que vértices do grafo original), conexo (para garantir a
use a menor quantidade de fibra ótica possı́vel. interligação de todas as cidades) e cuja soma dos custos
de suas arestas seja a menor possı́vel.
Este problema pode ser modelado por um problema em Obviamente, o problema só tem solução se o grafo for
grafos não orientados ponderados onde os vértices conexo. Daqui pra frente vamos supor que o grafo de
representam os computadores, as arestas representam as entrada é conexo.
conexões que podem ser construı́das e o peso/custo de Além disso, o sugrafo gerador procurado é sempre uma
uma aresta representa a quantidade de fibra ótica árvore (supondo que os pesos são positivos).
necessária.

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1
Árvore Geradora Mı́nima Exemplo

8 7
b c d
Problema da Árvore Geradora Mı́nima 4 9
2
a 11 i 4 14 e
Entrada: grafo conexo G = (V , E) com pesos w(u, v ) para 7 6
8 10
cada aresta (u, v ). h g f
1 2
Saı́da: subgrafo gerador conexo T de G cujo peso total
X
8 7
w(T ) = w(u, v ) b c d
(u,v )∈T 4 9
2
a 11 i 4 14 e
seja o menor possı́vel. 6
7
8 10
h g f
1 2

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1

Árvore Geradora Mı́nima Algoritmo genérico

A estratégia gulosa usada baseia-se em um algoritmo


genérico que constrói uma AGM incrementalmente.
Veremos dois algoritmos para resolver o problema:
O algoritmo mantém um conjunto de arestas A que
algoritmo de Prim satisfaz o seguinte invariante:
algoritmo de Kruskal
No inı́cio de cada iteração, A está contido em uma AGM.
Ambos algoritmos usam estratégia gulosa. Eles são
exemplos clássicos de algoritmos gulosos. Em cada iteração, determina-se uma aresta (u, v ) tal que
A′ = A ∪ {(u, v )} também satisfaz o invariante.
Uma tal aresta é chamada aresta segura (para A).

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1
Algoritmo genérico Como encontrar arestas seguras

AGM-G EN ÉRICO(G, w) Considere um grafo G = (V , E) e seja S ⊂ V .


1 A←∅ Denote por δ(S) o conjunto de arestas de G com um extremo
2 enquanto A não é uma árvore geradora em S e outro em V − S. Dizemos que um tal conjunto é um
3 Encontre uma aresta (u, v ) segura para A corte.
4 A ← A ∪ {(u, v )}
5 devolva A 8 7
b c d
4 9
Obviamente o “algoritmo” está correto! 2
a 11 i 4 14 e S
Note que nas linhas 2–4 A está propriamente contido em uma 7 6
AGM, digamos T . Logo, existe uma aresta segura (u, v ) em 8 10 V −S
h g f
T − A. 1 2

Naturalmente, para que isso seja um algoritmo de verdade, é


Um corte δ(S) respeita um conjunto A de arestas se não
preciso especificar como encontrar uma aresta segura.
contém nenhuma aresta de A.

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1

Como encontrar arestas seguras Como encontrar arestas seguras


Uma aresta de um corte δ(S) é leve se tem o menor peso entre
as arestas do corte.

Teorema 23.1: (CLRS)


Corolário 23.2 (CLRS)
Seja G um grafo com pesos nas arestas dado por w. Seja A
Seja G um grafo com pesos nas arestas dado por w. Seja A
um subconjunto de arestas contido em uma AGM. Seja δ(S)
um subconjunto de arestas contido em uma AGM. Seja C um
um corte que respeita A e (u, v ) uma aresta leve desse corte.
componente (árvore) de GA = (V , A). Se (u, v ) é uma aresta
Então (u, v ) é uma aresta segura.
leve de δ(C), então (u, v ) é segura para A.

8 7
b c d Os algoritmos de Prim e Kruskal são especializações do
4 9 algoritmo genérico e fazem uso do Corolário 23.2.
2
a 11 i 4 14 e S
7 6
8 10 V −S
h g f
1 2

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1
O algoritmo de Prim O algoritmo de Prim

No algoritmo de Prim, o conjunto A é uma árvore com raiz


r (escolhido arbitrariamente no inı́cio). Inicialmente, A é 8 7
vazio. b c d
4 9
Em cada iteração, o algoritmo considera o corte δ(C) onde 2
C é o conjunto de vértices que são extremos de A. a 11 i 4 14 e
7 6
Ele encontra uma aresta leve (u, v ) neste corte e
acrescenta-a ao conjunto A e começa outra iteração até
8 10
que A seja uma árvore geradora. h g f
1 2
Um detalhe de implementação importante é como encontrar
eficientemente uma aresta leve no corte.

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1

O algoritmo de Prim O algoritmo de Prim

8 7 8 7
b c d b c d
4 9 4 9
2 2
a 11 i 4 14 e a 11 i 4 14 e
7 6 7 6
8 10 8 10
h g f h g f
1 2 1 2

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1
O algoritmo de Prim O algoritmo de Prim

8 7 8 7
b c d b c d
4 9 4 9
2 2
a 11 i 4 14 e a 11 i 4 14 e
7 6 7 6
8 10 8 10
h g f h g f
1 2 1 2

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1

O algoritmo de Prim O algoritmo de Prim

8 7 8 7
b c d b c d
4 9 4 9
2 2
a 11 i 4 14 e a 11 i 4 14 e
7 6 7 6
8 10 8 10
h g f h g f
1 2 1 2

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1
O algoritmo de Prim O algoritmo de Prim

8 7 8 7
b c d b c d
4 9 4 9
2 2
a 11 i 4 14 e a 11 i 4 14 e
7 6 7 6
8 10 8 10
h g f h g f
1 2 1 2

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1

O algoritmo de Prim O algoritmo de Prim

O algoritmo mantém durante sua execução as seguintes


AGM-P RIM(G, w, r )
informações:
1 para cada u ∈ V [G]
Todos os vértices que não estão na árvore estão em uma 2 faça key[u] ← ∞
fila de prioridade (de mı́nimo) Q. 3 π[u] ← NIL
4 key[r ] ← 0
Cada vértice v em Q tem uma chave key[v ] que indica o 5 Q ← V [G]
menor peso de qualquer aresta ligando v a algum vértice 6 enquanto Q 6= ∅ faça
da árvore. Se não existir nenhuma aresta, então 7 u ← E XTRACT-M IN(Q)
key[v ] = ∞. 8 para cada v ∈ Adj[u]
A variável π[u] indica o pai de u na árvore. Então 9 se v ∈ Q e w(u, v ) < key[v ]
10 então π[v ] ← u
A = {(u, π[u]) : u ∈ V − {r } − Q}. 11 key[v ] ← w(u, v )

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1
Corretude do algoritmo de Prim Complexidade do algoritmo de Prim
Obviamente, a complexidade de AGM-P RIM depende de como
a fila de prioridade Q é implementada.
O algoritmo mantém os seguintes invariantes.
Vejamos o que acontece se implementarmos Q como um
min-heap.
No inı́cio de cada iteração das linhas 6–11:
A = {(u, π[u]) : u ∈ V − {r } − Q}. As linhas 1–5 podem ser executadas em tempo O(V )
usando B UILD -M IN -H EAP.
O conjunto de vértices da árvore é exatamente V [G] − Q. O laço da linha 6 é executado |V | vezes e cada operação
E XTRACT-M IN consome tempo O(lg V ), resultando em um
Para cada v ∈ Q, se π[v ] 6= NIL, então key[v ] é o peso de
tempo total O(V lg V ) para todas as chamadas de
uma aresta (v , π[v ]) de menor peso ligando v a um vértice
E XTRACT-M IN.
π[v ] na árvore.
O laço das linhas 8–11 é executado O(E) vezes no total.
Esse invariantes garantem que o algoritmo sempre escolhe O teste de pertinência de na fila Q pode ser feito em
uma aresta segura para acrescentar a A e portanto, o tempo constante usando um vetor de bits (booleano).
algoritmo está correto. Ao atualizar a chave de um vértice na linha 11 é feita uma
chamada implı́cita a D ECREASE -K EY que consome tempo
O(lg V ).
O tempo total é O(V lg V + E lg V ) = O(E lg V ).
Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1

Complexidade do algoritmo de Prim O algoritmo de Kruskal


Pode-se fazer melhor usando uma estrutura de dados
chamada heap de Fibonacci que guarda |V | elementos e
suporta as seguintes operações: No algoritmo de Kruskal o subgrafo F = (V , A) é uma
floresta. Inicialmente, A é vazio.
E XTRACT-M IN – O(lg V ),
D ECREASE -K EY – tempo amortizado O(1). Em cada iteração, o algoritmo escolhe uma aresta (u, v )
I NSERT – tempo amortizado O(1). de menor peso que liga vértices de componentes
(árvores) distintos C e C ′ de F = (V , A).
Outras operações eficientes que um min-heap não
suporta. Por exemplo, U NION. Note que (u, v ) é uma aresta leve do corte δ(C).
Maiores detalhes no CLRS (para quem quiser ver). Ele acrescenta (u, v ) ao conjunto A e começa outra
iteração até que A seja uma árvore geradora.
Usando um heap de Fibonacci para implementar Q
melhoramos o tempo para O(E + V lg V ). Um detalhe de implementação importante é como encontrar a
Este é um resultado interessante do ponto de vista teórico. aresta de menor peso ligando componentes distintos.
Na prática, a implementação anterior comporta-se muito
melhor.
Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1
O algoritmo de Kruskal O algoritmo de Kruskal

8 7
8 7 b c d
b c d
4 9
4 9 2
2 a 11 14 e
11 14 i 4
a i 4 e 6
6 7
7 8 10
8 10 h g f
h g f 1 2
1 2

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1

O algoritmo de Kruskal O algoritmo de Kruskal

8 7 8 7
b c d b c d

4 9 4 9
2 2
11 14 a 11 i 4 14 e
a i 4 e
6 7 6
7
8 10 8 10
h h g f
g f
1 2 1 2

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1
O algoritmo de Kruskal O algoritmo de Kruskal

8 7 8 7
b c d b c d
4 9 4 9
2 2
a 11 i 4 14 e a 11 i 4 14 e
7 6 7 6
8 10 8 10
h g f h g f
1 2 1 2

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1

O algoritmo de Kruskal O algoritmo de Kruskal

8 7
b c d 8 7
b c d
4 9
2 4 9
a 11 14 e
2
i 4 11 14
6 a i 4 e
7 6
8 10 7
h
8 10
g f
1 2 h g f
1 2

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1
O algoritmo de Kruskal O algoritmo de Kruskal

8 7 8 7
b c d b c d
4 9 4 9
2 2
a 11 i 4 14 e a 11 i 4 14 e
7 6 7 6
8 10 8 10
h g f h g f
1 2 1 2

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1

O algoritmo de Kruskal O algoritmo de Kruskal

8 7
8 7 b c d
b c d
4 9
4 9 2
2 a 11 14 e
11 14 i 4
a i 4 e 6
6 7
7 8 10
8 10 h g f
h g f 1 2
1 2

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1
O algoritmo de Kruskal O algoritmo de Kruskal

8 7 8 7
b c d b c d
4 9 4 9
2 2
a 11 i 4 14 e a 11 i 4 14 e
7 6 7 6
8 10 8 10
h g f h g f
1 2 1 2

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1

O algoritmo de Kruskal O algoritmo de Kruskal

Eis uma versão 0.0001 do algoritmo de Kruskal.


8 7
b c d AGM-K RUSKAL(G, w)
4 9 1 A←∅
2 2 Ordene as arestas em ordem não-decrescente de peso
a 11 i 4 14 e 3 para cada (u, v ) ∈ E nessa ordem faça
6 4 se u e v estão em componentes distintos de (V , A)
7
8 10 5 então A ← A ∪ {(u, v )}
h 6 devolva A
g f
1 2
Problema: Como verificar eficientemente se u e v estão no
mesmo componente da floresta GA = (V , A)?

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1
O algoritmo de Kruskal ED para conjuntos disjuntos

Inicialmente GA = (V , ∅), ou seja, GA corresponde à floresta


onde cada componente é um vértice isolado.
Uma estrutura de dados para conjuntos disjuntos mantém
Ao longo do algoritmo, esses componentes são modificados uma coleção {S1 , S2 , . . . , Sk } de conjuntos disjuntos
pela inclusão de arestas em A. dinâmicos (isto é, eles mudam ao longo do tempo).
Uma estrutura de dados para representar GA = (V , A) deve ser Cada conjunto é identificado por um representante que é
capaz de executar eficientemente as seguintes operações: um elemento do conjunto.

Dado um vértice u, determinar o componente de GA que Quem é o representante é irrelevante, mas se o conjunto
contém u e não for modificado, então o representante não pode
mudar.
dados dois vértices u e v em componentes distintos C e
C ′ , fazer a união desses em um novo componente.

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1

ED para conjuntos disjuntos Componentes conexos

Uma estrutura de dados para conjuntos disjuntos deve ser C ONNECTED -C OMPONENTS(G)
capaz de executar as seguintes operações: 1 para cada vértice v ∈ V [G] faça
2 M AKE -S ET(v )
M AKE -S ET(x): cria um novo conjunto {x}. 3 para cada aresta (u, v ) ∈ E[G] faça
U NION(x, y): une os conjuntos (disjuntos) que contém x e 4 se F IND -S ET(u) 6= F IND -S ET(v )
y, digamos Sx e Sy , em um novo conjunto Sx ∪ Sy . 5 então U NION(u, v )

Os conjuntos Sx e Sy são descartados da coleção. S AME -C OMPONENT(u, v )


1 se F IND -S ET(u) = F IND -S ET(v )
F IND -S ET(x) devolve um apontador para o representante 2 então devolva SIM
do (único) conjunto que contém x. 3 senão devolva NÃO

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1
Componentes conexos O algoritmo de Kruskal

Eis a versão completa!

“Complexidade” de C ONNECTED -C OMPONENTS AGM-K RUSKAL(G, w)


1 A←∅
2 para cada v ∈ V [G] faça
|V | chamadas a M AKE -S ET 3 M AKE -S ET(v )
2|E| chamadas a F IND -S ET 4 Ordene as arestas em ordem não-decrescente de peso
≤ |V | − 1 chamadas a U NION 5 para cada (u, v ) ∈ E nessa ordem faça
6 se F IND -S ET(u) 6= F IND -S ET(v )
7 então A ← A ∪ {(u, v )}
8 U NION(u, v )
9 devolva A

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1

O algoritmo de Kruskal ED para conjuntos disjuntos

Seqüência de operações M AKE -S ET, U NION e F IND -S ET


“Complexidade” de AGM-K RUSKAL
M M M U F U U F U F F F U F
| {z }
Ordenação: O(E lg E)
n
|V | chamadas a M AKE -S ET | {z }
2|E| chamadas a F IND -S ET m
≤ |V | − 1 chamadas a U NION
Vamos medir a complexidade das operações em termos de n e
A complexidade depende de como essas operações são m.
implementadas.
Que estrutura de dados usar?
Ou seja, como representar os conjuntos?

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1
Representação por listas ligadas Representação por listas ligadas

M AKE -S ET(x) – O(1)


b d a c F IND -S ET(x) – O(1)
U NION(x, y) – concatena a lista de x no final da lista de y

b d a c e g f
e g f

O(n) no pior caso


Cada conjunto tem um representante (inı́cio da lista) É preciso atualizar os apontadores para o representante.
Cada nó tem um campo que aponta para o representante
Guarda-se um apontador para o fim da lista
Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1

Um exemplo de pior caso Uma heurı́stica muito simples

Operação Número de atualizações


M AKE -S ET(x1 ) 1
M AKE -S ET(x2 ) 1 No exemplo anterior, cada chamada de U NION requer em
.. .. média tempo Θ(n) pois concatemos a maior lista no final da
. .
M AKE -S ET(xn ) 1 menor.
U NION(x1 , x2 ) 1
Uma idéia simples para evitar esta situação é sempre
U NION(x2 , x3 ) 2
U NION(x3 , x4 ) 3 concatenar a menor lista no final da maior (weighted-union
.. .. heuristic.)
. .
U NION(xn−1 , xn ) n-1 Para implementar isto basta guardar o tamanho de cada lista.
Uma única execução de U NION pode gastar tempo O(n), mas
Número total de operações: 2n − 1
na média o tempo é bem menor (próximo slide).
Custo total: Θ(n2 )
Custo amortizado de cada operação: O(n)

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1
Uma heurı́stica muito simples Representação por disjoint-set forests

Teorema. Usando a representação por listas ligadas e


weighted-union heuristic, uma seqüência de m operações
M AKE -S ET, U NION e F IND -S ET gasta tempo O(m + n lg n).
Prova. Veremos agora a representação por disjoint-set forests.
O tempo total em chamadas a M AKE -S ET e F IND -S ET é O(m). Implementações ingênuas não são assintoticamente
melhores do que a representação por listas ligadas.
Sempre que o apontador para o representante de um elemento
x é atualizado, o tamanho da lista que contém x (pelo menos) Usando duas heurı́sticas — union by rank e path
dobra. compression — obtemos a representação por disjoint-set
forests mais eficiente conhecida.
Após ser atualizado ⌈lg k⌉ vezes, a lista tem tamanho pelo
menos k. Como k tem que ser menor que n, cada apontador é
atualizado no máximo O(lg n) vezes.
Assim, o tempo total em chamadas a U NION é O(n lg n).

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1

Representação por disjoint-set forests Representação por disjoint-set forests

b e h j
a b e f h j

G a d g f i

c d g i
c
Grafo com vários componentes.
Como é a representação dos componentes na estrutura de Cada conjunto corresponde a uma árvore enraizada.
dados disjoint-set forests? Cada elemento aponta para seu pai.
A raiz é o representante do conjunto e aponta para si
mesma.

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1
Representação por disjoint-set forests Representação por disjoint-set forests

b e h j
U NION(a, f )
b x′ h j

a d g f i
a d e y′ i

c
c g f
M AKE -S ET(x)
1 pai[x] ← x U NION(x, y)
1 x ′ ← F IND -S ET(x)
F IND -S ET(x) 2 y ′ ← F IND -S ET(y )
1 se x = pai[x] 3 pai[y ′ ] ← x ′
2 então devolva x
3 senão devolva F IND -S ET(pai[x])

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1

Representação por disjoint-set forests Representação por disjoint-set forests

U NION(a, f )
b x′ h j
Com a implementação descrita até agora, não há melhoria
assintótica em relação à representação por listas ligadas.
a d e y′ i É fácil descrever uma seqüência de n − 1 chamadas a U NION
que resultam em uma cadeia linear com n nós.

g f Pode-se melhorar (muito) isso usado duas heurı́sticas:


c
union by rank
U NION(x, y) path compression
1 x ′ ← F IND -S ET(x)
2 y ′ ← F IND -S ET(y )
3 pai[y ′ ] ← x ′

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1
Union by rank Union by rank

M AKE -S ET(x)
1 pai[x] ← x
2 rank[x] ← 0
A idéia é emprestada do weighted-union heuristic.
U NION(x, y)
Cada nó x possui um “posto” rank[x] que é um limitante
1 L INK(F IND -S ET(x), F IND -S ET(y ))
superior para a altura de x.
Em union by rank a raiz com menor rank aponta para a raiz L INK(x, y) ⊲ x e y são raı́zes
com maior rank. 1 se rank[x] > rank[y]
2 então pai[y] ← x
3 senão pai[x] ← y
4 se rank[x] = rank[y]
5 então rank[y ] ← rank[y] + 1

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1

Path compression Path compression


A idéia é muito simples: ao tentar determinar o representante
A idéia é muito simples: ao tentar determinar o representante
(raiz da árvore) de um nó fazemos com que todos os nós no
(raiz da árvore) de um nó fazemos com que todos os nós no
caminho apontem para a raiz. e caminho apontem para a raiz.
e
d

c a c
b d
b

a F IND -S ET(x)

F IND -S ET(x)

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1
Path compression Análise de union by rank com path compression
e

d
Vamos descrever (sem provar) a complexidade de uma
c seqüência de operações M AKE -S ET, U NION e F IND -S ET
quando union by rank e path compression são usados.
b
Para k ≥ 0 e j ≥ 1 considere a função
a F IND -S ET(x)
(
j +1 se k = 0,
Ak (j) = (j+1)
Ak−1 (j) se k ≥ 1,
(j+1)
onde Ak −1 (j) significa que Ak −1 (j) foi iterada j + 1 vezes.
F IND -S ET(x)
1 se x 6= pai[x]
2 então pai[x] ← F IND -S ET(pai[x])
3 devolva pai[x]
Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1

Análise de union by rank com path compression Análise de union by rank com path compression

Ok. Você não entendeu o que esta função faz. . . Considere agora inversa da função Ak (n) definida como
Tudo que você precisa saber é que ela cresce muito rápido.
α(n) = min{k : Ak (1) ≥ n}.

A0 (1) = 2 Usando a tabela anterior temos


A1 (1) = 3 
0 para 0 ≤ n ≤ 2,


A2 (1) = 7 
 1 para n = 3,

A3 (1) = 2047 α(n) = 2 para 4 ≤ n ≤ 7,

 3 para 8 ≤ n ≤ 2047,
A4 (1) = 16512



4 para 2048 ≤ n ≤ A4 (1).

Em particular, A4 (1) = 16512 ≫ 1080 que é número estimado


Ou seja, para efeitos práticos α(n) ≤ 4.
de átomos do universo. . .

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1
Análise de union by rank com path compression O algoritmo de Kruskal (de novo)

AGM-K RUSKAL(G, w)
1 A←∅
2 para cada v ∈ V [G] faça
Teorema. Uma seqüência de m operações M AKE -S ET, U NION 3 M AKE -S ET(v )
e F IND -S ET pode ser executada em uma ED para disjoint-set 4 Ordene as arestas em ordem não-decrescente de peso
forests com union by rank e path compression em tempo 5 para cada (u, v ) ∈ E nessa ordem faça
O(mα(n)) no pior caso. 6 se F IND -S ET(u) 6= F IND -S ET(v )
7 então A ← A ∪ {(u, v )}
Isto significa (na prática) que o tempo total é linear e que o
8 U NION(u, v )
custo amortizado por operação é uma constante.
9 devolva A
Vamos voltar agora à implementação do algoritmo de Kruskal. Complexidade:
Ordenação: O(E lg E)
|V | chamadas a M AKE -S ET
|E| + |V | − 1 = O(E) chamadas a U NION e F IND -S ET

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1 Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1

O algoritmo de Kruskal (de novo)

Ordenação: O(E lg E)
|V | chamadas a M AKE -S ET
O(E) chamadas a U NION e F IND -S ET

Usando a representação disjoint-set forests com union by rank


e path compression, o tempo gasto com as operações é
O((V + E)α(V )) = O(Eα(V )).
Como α(V ) = O(lg V ) = O(lg E) o passo que consome mais
tempo no algoritmo de Kruskal é a ordenação.
Logo, a complexidade do algoritmo é O(E lg E) = O(E lg V ).

Cid Carvalho de Souza, Cândida Nunes da Silva, Orlando Lee MO417 — Complexidade de Algoritmos – v. 2.1