Árvore Geradora Mínima

O problema

Admita que tenhamos que conectar vértices de forma eficiente, onde os vértices podem ser: computadores, telefones, etc. Uma árvore geradora mínima deve fornecer uma solução econômica, que precise de pouco cabo, tubulação, ou pouca quantidade de qualquer que seja o meio de conexão (arestas)

Definição

Uma árvore geradora de um grafo é uma árvore não-enraizada cujo conjunto de vértices coincide com o conjunto de vértices do grafo cujas arestas são (algumas das) arestas do grafo.

Portanto...

Uma árvore geradora conecta todos os vértices de um grafo sem formar ciclos.

Um dos algoritmos utilizados é o PRIM. Ele é parecido com o algoritmo para o caminho mínimo, sendo que, um grafo poderá ter mais de uma árvore geradora mínima.

Exemplo

Algoritmo PRIM

-Cria-se um conjunto IN que inicialmente terá um vértice arbitrário (z)

-Para cada vértice de (z) que não esteja em IN, avaliamos a menor distância.

-A aresta que realiza a distância mínima é então incluída na árvore geradora mínima.

-O algoritmo termina quando todos os vértices do grafo pertençam a IN.

Algoritmo PRIM(execução)

Exemplo:

c(F) = 1c(F) = 1

H

A

B

J

C

E

M L

G

D

I

F

4

7

4

3

7

5

6

2

23

1

4

2

3

8

6

4

c(F) = 3c(F) = 3c(F) = 6c(F) = 6c(F) = 9c(F) = 9c(F) = 11c(F) = 11c(F) = 13c(F) = 13c(F) = 17c(F) = 17c(F) = 21c(F) = 21c(F) = 25c(F) = 25c(F) = 28c(F) = 28c(F) = 33c(F) = 33

Algoritmo (Pseudo-código)

função Prim(G)

{

T := {} B := Um vértice de G Enquanto B não contém todos os vértices

(u,v) :=   aresta de menor peso saindo de todos os vértices em B

T :=   T U {(u,v)}B :=   B U {u}

}

Algoritmos de busca

Os problemas vistos até agora baseavam-se em alguma premissa do tipo: não passar pela mesma aresta, não passar pelo mesmo vértice, minimizar a distância percorrida, etc.

Agora veremos algoritmos onde podemos percorrer todos os vértices em uma ordem particular, mas listando todos os vértice.

Busca em profundidade

Neste procedimento, partimos de um vértice a e marcamos ele como visitado, prosseguindo para o ponto mais longe possível, até que nenhum vértice seja mais encontrado pelo caminho escolhido.

Busca em profundidadePara um grafo simples e conexo

Procedure profundidade(G, a){ marque a como visitado escreva a for (cada vertice n adjacente de a) if n não foi visitado profundidade(G, n)}

Busca em largura

Neste caso partimos do vértice a e seguimos por todos os seus adjacentes, em seguida seguimos cada um desses adjacentes, realizando a mesma operação.

Busca em Largura (usando lista)Procedure largura(G, a){

Q: Fila de verticesmarque aescreva(a)inclui(a) na filaEnquanto Q não está vaziafor cada vértice n adjacente a Q

if n não foi visitadomarque n como visitadoescreva(n)incluiNa Fila (n,Q)

TiraDaFila(q)}

AnálisesA vantagem de se utilizar lista de adjacências no lugar de matriz, é interessante para a implementação, uma vez que torna o algoritmo muito mais simples. (como seria percorrer todos os adjacentes de a, em uma matriz?)

Varrer a lista de adjacências o grafo determina a quantidade de trabalho a ser realizada em cada lado. Como existem n listas de adjacências, a quantidade de trabalho é pelo menos O(n), pois mesmo que ela esteja vazia, precisa ser verificada. Como existem M arestas, o trabalho para percorrer todas as arestas de uma lista é o(m). Portanto, os algoritmos são O(max(n,m)). O caso mais comum provavelmente é O(m) pois em geral temos mais arestas do que vértices.

Busca em arvores

Os algoritmos de busca em largura e em profundidade se aplicam a quaisquer grafos, porém, existem 3 outros algoritmos apenas para árvores que são úteis.

Pré-ordem

InOrdem

PosOrdem

ABDCEGFHI

Pré-Ordem

IN-Ordem

DBAEGCHFI

DBGEHIFCA

Pós-Ordem

PreOrdem

Procedure PreOrdem(N:Pno);

If N <> nil Then

Processa(N); {p. ex. imprime} PreOrdem(N^.esq);

PreOrdem(N^.dir);

End;

End;

InOrdem

Procedure InOrdem(N:Pno);

If N <> nil Then

InOrdem(N^.esq);

Processa(N); {p. ex: imprime}

InOrdem(N^.dir);

End;

End;

PosOrdem

Procedure PosOrdem(N:Pno)

If N <> nil Then

PosOrdem(N^.esq);

PosOrdem(N^.dir);

Processa(N); {p.ex.: imprime}

End;

End;

Exercícios

1.Crie o grafo a1(1,2,5); a2(2,5,3); a3(2,3,3); a4(4,2,3); a5(3,1,3) e faça a conexão utilizando o algoritmo PRIM

2.Percorra a árvore ao lado das 3 formas possíveis