Matemática Discreta – Lista de Exercícios

1) Considere o seguinte grafo:

a) Faça o teste de mesa (apresentando o valor de todas as variáveis em cada

iteração) do Algoritmo de Dijkstra, iniciando em ‘c’.
Iteração 1: Inicialmente, vamos iniciar no vértice 'c'. Configuramos a distância do vértice
'c' como 0 e todas as outras distâncias como infinito. Definimos o predecessor de todos os
vértices como vazio e criamos um conjunto vazio S para armazenar os vértices visitados e
um conjunto R com os nós que restam. Selecionamos o vértice com a menor distância
atual que ainda não foi visitado. Nesse caso, o vértice 'c' é selecionado.

S = [‘c’] e R = [‘a’, ‘b’, ‘d’, ‘e’, ‘f’, ‘g’, ‘z’]

Vértice Distância Predecessor

a infinito vazio
b infinito vazio
c 0 vazio
d infinito vazio
e infinito vazio
f infinito vazio
g infinito vazio
z infinito vazio
Iteração 2: Agora vamos analisar todos os vértices adjacentes a ‘c’ e ver se a distância
atual + peso da aresta (custo) é menor do que a distância armazenada atualmente para
cada vértice adjacente.

S = [‘c’] e R = [‘a’, ‘b’, ‘d’, ‘e’, ‘f’, ‘g’, ‘z’]

Vértice Distância Predecessor

a 10 c
b 2 c
c 0 vazio
d 4 c
e 10 c
f 12 c
g infinito vazio
z infinito vazio

Iteração 3: Agora vamos selecionar o vértice com a menor distância atual que ainda não
foi visitado, nesse caso, o vértice 'b' é selecionado. Verificamos se a distância atual +
peso da aresta é menor do que a distância armazenada atualmente para cada vértice
adjacente

S = [‘c’, ‘b’] e R = [‘a’, ‘d’, ‘e’, ‘f’, ‘g’, ‘z’]

Vértice Distância Predecessor

a 10 c
b 2 c
c 0 vazio
d 4 c
e 10 c
f 6 b
g 8 b
z infinito vazio
 Iteração 4: Selecionamos o vértice com a menor distância atual que ainda não foi
visitado, nesse caso, o vértice 'd' é selecionado. Verificamos se a distância atual + peso
da aresta é menor do que a distância armazenada atualmente para cada vértice adjacente

S = [‘c’, ‘b’, ‘d’] e R = [‘a’ , ‘e’, ‘f’, ‘g’, ‘z’]

Vértice Distância Predecessor

a 9 d
b 2 c
c 0 vazio
d 4 c
e 10 c
f 6 b
g 8 b
z infinito vazio

Iteração 5: Selecionamos o vértice com a menor distância atual que ainda não foi
visitado, nesse caso, o vértice 'f' é selecionado. Verificamos se a distância atual + peso da
aresta é menor do que a distância armazenada atualmente para cada vértice adjacente.
S = [‘c’, ‘b’, ‘d’, ‘f’] e R = [‘a’ , ‘e’, ‘g’, ‘z’]

Vértice Distância Predecessor

a 9 d
b 2 c
c 0 vazio
d 4 c
e 9 f
f 6 b
g 8 b
z 22 f

Iteração 6: Selecionamos o vértice com a menor distância atual que ainda não foi
visitado, nesse caso, o vértice 'g' é selecionado. Verificamos se a distância atual + peso
 da aresta é menor do que a distância armazenada atualmente para cada vértice
adjacente.
S = [‘c’, ‘b’, ‘d’, ‘f’, ‘g’] e R = [‘a’ , ‘e’, ‘z’]

Vértice Distância Predecessor

a 9 d
b 2 c
c 0 vazio
d 4 c
e 9 f
f 6 b
g 8 b
z 15 g

Iteração 7: Selecionamos o vértice com a menor distância atual que ainda não foi
visitado, porém 2 vértices estão com as distâncias iguais, por conta disso, selecionaremos
por ordem alfabética, mas caso fosse escolhido qualquer outro com valor igual, não
alteraria o resultado final, tampouco o número de iterações, logo o vértice 'a' é
selecionado. Verificamos se a distância atual + peso da aresta é menor do que a distância
armazenada atualmente para cada vértice adjacente.
S = [‘c’, ‘b’, ‘d’, ‘f’, ‘g’, ‘a’] e R = [‘e’, ‘z’]

Vértice Distância Predecessor

a 9 d
b 2 c
c 0 vazio
d 4 c
e 9 f
f 6 b
g 8 b
z 15 g

Como não houve nenhum vértice que pudesse satisfazer a condição, nada foi alterado
 Iteração 8: Selecionamos o vértice com a menor distância atual que ainda não foi
visitado, nesse caso, o vértice 'e' é selecionado. Verificamos se a distância atual + peso
da aresta é menor do que a distância armazenada atualmente para cada vértice
adjacente.
S = [‘c’, ‘b’, ‘d’, ‘f’, ‘g’, ‘a’, ‘e’] e R = [‘z’]

Vértice Distância Predecessor

a 9 d
b 2 c
c 0 vazio
d 4 c
e 9 f
f 6 b
g 8 b
z 14 e

Iteração 9: Como ‘z’ é o último vértice, ele é selecionado

S = [‘c’, ‘b’, ‘d’, ‘f’, ‘g’, ‘a’, ‘e’] e R = []

Vértice Distância Predecessor

a 9 d
b 2 c
c 0 vazio
d 4 c
e 9 f
f 6 b
g 8 b
z 14 e

Como não existe caminho mais curto passando por ‘z’, concluímos o algoritmo de dijkstra

b) Faça o teste de mesa (apresentando o valor de todas as variáveis em cada

iteração) do Algoritmo de Prim, iniciando do nó ‘a’
Iteração 1: Iniciamos o algoritmo do vértice ‘a’, onde ← significa recebe o valor a direita, T
← ‘a’ e V ← N – [‘a’], em que T são os nós visitados, N é o conjunto de todos os nós do
grafo e V é o conjunto dos nós ainda não analisados
Iteração 2: Agora temos de encontrar a menor aresta do grafo, tal que o nó inicial
pertença à T e o nó final pertença a V que seriam:

T = [‘a’], V = [‘b’, ‘c’, ‘d’, ‘e’, ‘f’, ‘g’, ‘z’]

Nó inicial Nó adjacente Peso

a b 16
a c 10
a d 5

T ←T + [d]
V←V - [d]
Sendo S uma lista com as arestas da árvore geradora mínima
S ← S + [(a, d)]

Iteração 3: Agora temos de encontrar a menor aresta do grafo, tal que o nó inicial
pertença à T e o nó final pertença a V que seriam:

S = [(a, d)]
T = [‘a’, ‘d’], V = [‘b’, ‘c’, ‘e’, ‘f’, ‘g’, ‘z’]

Nó inicial Nó adjacente Peso

a b 16
a c 10
d c 4
d e 15

T ←T + [c]
V←V - [c]
S ← S + [(d, c)]
Iteração 4: Agora temos de encontrar a menor aresta do grafo, tal que o nó inicial
pertença à T e o nó final pertença a V que seriam:

S = [(a, d), (d, c)]

T = [‘a’, ‘d’, ‘c’], V = [‘b’, ‘e’, ‘f’, ‘g’, ‘z’]

Nó inicial Nó adjacente Peso

a b 16
a c 10
d e 15
c b 2
c e 10
c f 12

T ←T + [b]
V←V - [b]
S ← S + [(c, b)]

Iteração 5: Agora temos de encontrar a menor aresta do grafo, tal que o nó inicial
pertença à T e o nó final pertença a V que seriam:

S = [(a, d), (d, c), (c, b)]

T = [‘a’, ‘d’, ‘c’, ‘b’], V = [‘e’, ‘f’, ‘g’, ‘z’]

Nó inicial Nó adjacente Peso

a b 16
a c 10
d e 15
c e 10
c f 12
b f 4
b b 6

T ←T + [f]
V←V - [f]
S ← S + [(b, f)]

Iteração 6: Agora temos de encontrar a menor aresta do grafo, tal que o nó inicial
pertença à T e o nó final pertença a V que seriam:

S = [(a, d), (d, c), (c, b), (b, f)]

 T = [‘a’, ‘d’, ‘c’, ‘b’, ‘f’], V = [‘e’, ‘g’, ‘z’]

Nó inicial Nó adjacente Peso

a b 16
a c 10
d e 15
c e 10
c f 12
b g 6
f e 3
f g 8
f z 16

T ←T + [e]
V←V - [e]
S ← S + [(f, e)]

Iteração 7: Agora temos de encontrar a menor aresta do grafo, tal que o nó inicial
pertença à T e o nó final pertença a V que seriam:

S = [(a, d), (d, c), (c, b), (b, f), (f, e)]
T = [‘a’, ‘d’, ‘c’, ‘b’, ‘f’, ‘e’], V = [‘g’, ‘z’]

Nó inicial Nó adjacente Peso

a b 16
a c 10
d e 15
c e 10
c f 12
b g 6
f e 3
f g 8
f z 16
e z 5

T ←T + [z]
V←V - [z]
S ← S + [(e, z)]
Iteração 8: Agora temos de encontrar a menor aresta do grafo, tal que o nó inicial
pertença à T e o nó final pertença a V que seriam:

S = [(a, d), (d, c), (c, b), (b, f), (f, e), (e, z)]
T = [‘a’, ‘d’, ‘c’, ‘b’, ‘f’, ‘e’, ‘z’], V = [‘g’]

Nó inicial Nó adjacente Peso

a b 16
a c 10
d e 15
c e 10
c f 12
b g 6
f e 3
f g 8
f z 16
z g 7

T ←T + [g]
V←V - [g]
S ← S + [(b, g)]
S = [(a, d), (d, c), (c, b), (b, f), (f, e), (e, z), (b, g)]

c) Faça o teste de mesa (apresentando o valor de todas as variáveis em cada

iteração) do Algoritmo de Kruskal

Iteração 1: Vamos primeiramente organizar todas as arestas em ordem crescente

 Nó inicial Nó adjacente Peso
b c 2
e f 3
b f 4
c d 4
a d 5
e z 5
b g 6
g z 7
f g 8
a c 10
c e 10
c f 12
d e 15
a b 16
f z 16

Agora, criaremos uma lista T, onde T armazenará as arestas de menor valor, verificando
se ao adicionar um novo nó não estamos criando um laço (ciclo). O algoritmo termina
quando todas as arestas forem visitadas
Logo, T inicia vazio, mas fazendo a iniciação da variável:
T = []
T ← T +[(b, c)]
E retiramos a aresta adicionada à T

Nó inicial Nó adjacente Peso

e f 3
b f 4
c d 4
a d 5
 e z 5
b g 6
g z 7
f g 8
a c 10
c e 10
c f 12
d e 15
a b 16
f z 16

Iteração 2: primeiramente analisamos se conjunto T forma um ciclo. Como não forma,

adicionamos a próxima aresta.
T = [(b, c)]
T ← T +[(e, f)]
E retiramos a aresta adicionada à T

Nó inicial Nó adjacente Peso

b f 4
c d 4
a d 5
e z 5
b g 6
g z 7
f g 8
a c 10
c e 10
c f 12
d e 15
a b 16
f z 16

Iteração 3: primeiramente analisamos se conjunto T forma um ciclo. Como não forma,

adicionamos a próxima aresta.
T = [(b, c), (e, f)]
T ← T +[(b, f)]
E retiramos a aresta adicionada à T

Nó inicial Nó adjacente Peso

 c d 4
a d 5
e z 5
b g 6
g z 7
f g 8
a c 10
c e 10
c f 12
d e 15
a b 16
f z 16

Iteração 4: primeiramente analisamos se conjunto T forma um ciclo. Como não forma,

adicionamos a próxima aresta.
T = [(b, c), (e, f), (b, f)]
T ← T +[(c, d)]
E retiramos a aresta adicionada à T

Nó inicial Nó adjacente Peso

a d 5
e z 5
b g 6
g z 7
f g 8
a c 10
c e 10
c f 12
d e 15
a b 16
f z 16

Iteração 5: primeiramente analisamos se conjunto T forma um ciclo. Como não forma,

adicionamos a próxima aresta.
T = [(b, c), (e, f), (b, f), (c, d)]
T ← T +[(a, d)]
E retiramos a aresta adicionada à T

Nó inicial Nó adjacente Peso

e z 5
 b g 6
g z 7
f g 8
a c 10
c e 10
c f 12
d e 15
a b 16
f z 16

Iteração 6: primeiramente analisamos se conjunto T forma um ciclo. Como não forma,

adicionamos a próxima aresta.
T = [(b, c), (e, f), (b, f), (c, d), (a, d)]
T ← T +[(e, z)]
E retiramos a aresta adicionada à T

Nó inicial Nó adjacente Peso

b g 6
g z 7
f g 8
a c 10
c e 10
c f 12
d e 15
a b 16
f z 16

Iteração 7: primeiramente analisamos se conjunto T forma um ciclo. Como não forma,

adicionamos a próxima aresta.
T = [(b, c), (e, f), (b, f), (c, d), (a, d), (e, z)]
T ← T +[(b, g)]
E retiramos a aresta adicionada à T

Nó inicial Nó adjacente Peso

g z 7
f g 8
 a c 10
c e 10
c f 12
d e 15
a b 16
f z 16

Iteração 8: primeiramente analisamos se conjunto T forma um ciclo. E neste caso, ele

forma um ciclo e caso qualquer nova aresta seja adicionada, o novo grafo formado
perderá a propriedade de ser uma árvore geradora mínima e formará ciclos.
Com isso, conclui-se que a A.G.M do grafo dado é:
T = [(b, c), (e, f), (b, f), (c, d), (a, d), (e, z), (b, g)]

d) Faça o teste de mesa (apresentando o valor de todas as variáveis em cada

iteração) do Algoritmo de Busca em Profundidade, iniciando em ‘a’.

Iteração 1:

Vamos chamar T de uma lista com os valores do algoritmo, sendo adicionado

primeiramente o nó inicial (‘a’), N como sendo o conjunto de todos os nós do grafo e
posteriormente os próximos da sequência do algoritmo.
Começamos com T = [] e N = [‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’, ‘g’, ‘z’]
T ← T + [‘a’]
N ← N - [‘a’]

Iteração 2: Percorreremos os nós de maneira recursiva, isso significa que a cada nova
chamada da função, teremos um novo grafo e iremos analisá-lo como tal. Com isso,
percorrendo a partir do nó ‘a’ e levando em consideração a ordem alfabética como meio
de escolha do próximo nó da busca, com os nós adjacentes como escolha, temos:
T = [‘a’] e N = [‘b’, ‘c’, ‘d’, ‘e’, ‘f’, ‘g’, ‘z’]
T ← T + [‘b’]
N ← N – [‘b’]

Iteração 3:
T = [‘a’, ‘b’] e N = [‘c’, ‘d’, ‘e’, ‘f’, ‘g’, ‘z’]
T ← T + [‘c’]
N ← N – [‘c’]

Iteração 4:
T = [‘a’, ‘b’, ‘c’] e N = [‘d’, ‘e’, ‘f’, ‘g’, ‘z’]
T ← T + [‘d’]
N ← N – [‘d’]
Iteração 5:
T = [‘a’, ‘b’, ‘c’, ‘d’] e N = [‘e’, ‘f’, ‘g’, ‘z’]
T ← T + [‘e’]
N ← N – [‘e’]
Iteração 6:
T = [‘a’, ‘b’, ‘c’, ‘d’, ‘e’] e N = [‘f’, ‘g’, ‘z’]
T ← T + [‘f’]
 N ← N – [‘f’]
Iteração 7:
T = [‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’] e N = [‘g’, ‘z’]
T ← T + [‘g’]
N ← N – [‘g’]
Iteração 8:

T = [‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’, ‘g’] e N = [‘z’]

T ← T + [‘z’]
N ← N – [‘z’]
Iteração 9:
T = [‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’, ‘g’, ‘z’] e N = []
E assim terminamos o algoritmo

e) Faça o teste de mesa (apresentando o valor de todas as variáveis em cada

iteração) do Algoritmo de Busca em Nível, iniciando em ‘a’.

Iteração 1: Vamos inicialmente marcar o nó ‘a’ e adicioná-lo a lista F. Vamos identificar os

nós adjacentes à ‘a’, que são: ‘b’, ‘c’ e ‘d’
F = []
F ← [‘a’]

Iteração 2: Para todos os nós adjacentes de ‘a’, adicionaremos a F.

F = [‘a’]
F ← [‘a’, ‘b’, ‘c’, ‘d’]

Iteração 3: Para todos os nós adjacentes de ‘b’, adicionaremos a F.

F = [‘a’, ‘b’, ‘c’, ‘d’]
F ← [‘f’, ‘g’]

Iteração 4: Para todos os nós adjacentes de ‘c’, adicionaremos a F.

F = [‘a’, ‘b’, ‘c’, ‘d’, ‘f’, ‘g’]
F ← [‘e’]

Iteração 5: Para todos os nós adjacentes de ‘d’, adicionaremos a F.

F = [‘a’, ‘b’, ‘c’, ‘d’, ‘f’, ‘g’, ‘e’]
F ← []
Como não existem nós adjacentes não marcados em ‘d’, nenhum valor é adicionado à F.

Iteração 6:Para todos os nós adjacentes de ‘f’, adicionaremos a F.

F = [‘a’, ‘b’, ‘c’, ‘d’, ‘f’, ‘g’, ‘e’]
F ← ‘z’

Iteração 7: Para todos os nós adjacentes de ‘g’, adicionaremos a F.

F = [‘a’, ‘b’, ‘c’, ‘d’, ‘f’, ‘g’, ‘e’, ‘z’]
F ← []

Iteração 8: Para todos os nós adjacentes de ‘e’, adicionaremos a F.

F = [‘a’, ‘b’, ‘c’, ‘d’, ‘f’, ‘g’, ‘e’, ‘z’]
F ← []
Iteração 9: Para todos os nós adjacentes de ‘z’, adicionaremos a F.
F = [‘a’, ‘b’, ‘c’, ‘d’, ‘f’, ‘g’, ‘e’, ‘z’]
F ← []

E assim, terminamos o algoritmo, onde ele percorreu todos os nós do grafo, sendo F a
lista que armazena o resultado, temos F = [‘a’, ‘b’, ‘c’, ‘d’, ‘f’, ‘g’, ‘e’, ‘z’].

2) Para o grafo abaixo, seja A a matriz e adjacências

a) Encontre A².
A = [(0 2 0 1),
(0 0 1 0),
(0 0 0 0),
(0 0 1 0)]

A² = [(0.0+2.0+0.0+1.0 2.0+0.0+0.0+1.0 0.0+2.1+0.0+1.1 0.1+2.0+0.0+1.0),

(0.0+0.0+1.0+0.0 0.2+0.0+1.0+0.0 0.0+0.1+1.0+0.1 0.1+0.0+1.0+0.0),
(0.0+0.0+0.0+0.0 0.2+0.0+0.0+0.0 0.0+0.1+0.0+0.1 0.1+0.0+0.0+0.0),
(0.0+0.0+1.0+0.0 0.2+0.0+1.0+0.0 0.0+0.1+1.0+0.1 0.1+0.0+1.0+0.0)

A² = [(0 0 2 0),
(0 0 0 0),
(0 0 0 0),
(0 0 0 0)]

b) Encontre 𝐴(2) .

𝐴(2) = [(0 0 1 0),

(0 0 0 0),
(0 0 0 0),
(0 0 0 0)]

c) Diga o que significa o elemento da linha 1 e coluna 3 na matriz A²

Significa que o nó 1 consegue chegar no nó 3 passando por 2 arestas.

3) Explique porque qualquer grafo que contém um circuito hamiltoniano é conexo.

Todo circuito Hamiltoniano é um caminho do qual se é capaz de passar por todas as arestas sem
repeti-las. Se uma aresta necessariamente precisa de estar entre 2 nós, vemos que um caminho
Hamiltoniano é impossível em grafos com nós não conectados e nós conectados a um único outro
nó. Dessa forma, podemos perceber que, se é estritamente necessário que todos os nós sejam
acessíveis e que seja formado um ciclo ao final do circuito para ser um circuito Hamiltoniano, então
todo circuito Hamiltoniano é certamente conexo.

4) Dado o grafo abaixo:

 a) Calcule a matriz de acessibilidade R = A ˅𝐴(2) v 𝐴(3) ˅ 𝐴(4) .

A = [(0 0 0 1),
(0 0 1 1),
(0 0 0 0),
(1 0 0 0)]

𝐴(2) = [(1 0 0 0),

(1 0 0 0),
(0 0 0 0),
(0 0 0 1)]

𝐴(3) = [(0 0 0 1),

(0 0 0 1),
(0 0 0 0),
(1 0 0 0)]

𝐴(4) = [(1 0 0 0),

(1 0 0 0),
(0 0 0 0),
(0 0 0 1)]

R = [(1 0 0 1),
(1 0 1 1),
(0 0 0 0),
(1 0 0 1)]

b) Qual a característica encontrada na 2ª coluna 2 R (de R?)? O que isso significa?

A 2ª coluna de R está com todos os seus valores zerados. Isso significa que não existe forma
possível de se acessar o nó desta coluna

5) É possível entrar e sair de cada quarto na casa ilustrada na figura a seguir de modo que
cada porta da casa seja usada exatamente uma vez? Por quê?
 Primeiramente, transformaremos um problema em algo mais simples e do qual o assunto é
dominado. Dessa forma, podemos enxergar este problema como um grafo, onde os espaços são os
nós e as portas são as arestas. De modo que fique:

Dado o grafo do problema, podemos visualizar de forma mais fácil. Se for observado atentamente,
vemos que o grafo possui 3 nós com 3 arestas e um com 5 nós, tornando impossível percorrer o
caminho sem repetir arestas. Isso porque só é possível percorrer todas as arestas do grafo (visto que
percorrer todas as arestas é um problema Hamiltoniano) caso houvesse apenas 2 nós ímpares com 3
arestas, mas como há 4 nós ímpares e 3 deles possuem 3 arestas, torna-se impossível percorrer o
caminho sem repetir aresta.