def main():
nome_arquivo = input("Digite o caminho do arquivo:")
# arquivo para leitura
arquivo = open(nome_arquivo, "r")
quantidade = int(arquivo.readline())
grafo = Grafo()
# salva os objetos criados para economizar espaco e utilizá-los
# na criação das arestas
vertices_criados = {}
primeiro_vertice = Vertice(1)
vertices_criados[1] = primeiro_vertice
grafo.adiciona_vertice(primeiro_vertice)
for i in range(2, quantidade + 1):
vertices_criados[i] = Vertice(i)
grafo.adiciona_vertice(vertices_criados[i])
for leitura in arquivo:
# separa dois valores pelo espaco
valores_vertices = leitura.split()
v1 = vertices_criados[int(valores_vertices[0])]
v2 = vertices_criados[int(valores_vertices[1])]
grafo.adiciona_aresta(v1, v2)
try:
resultado = encontrar_caminho_projetos(grafo, primeiro_vertice)
print("A solução para este problema é: ", resultado)
except Exception as ex:
print(ex)
def test_grau_separacao_victor(self):
grafo = Grafo()
grafo.adiciona_vertice("Victor")
grafo.adiciona_vertice("Gabriel Fallen")
grafo.adiciona_vertice("Maycon")
grafo.adiciona_vertice("Leticia")
grafo.adiciona_vertice("Giovana")
grafo.adiciona_vertice("Lorena")
grafo.adiciona_vertice("Felipe")
grafo.adiciona_vertice("Valentina")
grafo.adiciona_vertice("Juliana")
grafo.adiciona_vertice("Rubens")
grafo.adiciona_aresta("Victor", "Maycon")
grafo.adiciona_aresta("Victor", "Leticia")
grafo.adiciona_aresta("Victor", "Lorena")
grafo.adiciona_aresta("Victor", "Felipe")
grafo.adiciona_aresta("Maycon", "Victor")
grafo.adiciona_aresta("Maycon", "Juliana")
grafo.adiciona_aresta("Maycon", "Leticia")
grafo.adiciona_aresta("Leticia", "Giovana")
grafo.adiciona_aresta("Leticia", "Maycon")
grafo.adiciona_aresta("Leticia", "Victor")
grafo.adiciona_aresta("Giovana", "Leticia")
grafo.adiciona_aresta("Lorena", "Victor")
grafo.adiciona_aresta("Lorena", "Valentina")
grafo.adiciona_aresta("Lorena", "Felipe")
grafo.adiciona_aresta("Lorena", "Rubens")
grafo.adiciona_aresta("Felipe", "Victor")
grafo.adiciona_aresta("Felipe", "Lorena")
grafo.adiciona_aresta("Felipe", "Rubens")
grafo.adiciona_aresta("Valentina", "Lorena")
grafo.adiciona_aresta("Juliana", "Maycon")
grafo.adiciona_aresta("Rubens", "Felipe")
grafo.adiciona_aresta("Rubens", "Lorena")
distancias_esperadas_por_v_inicial = {
"Victor": {
"Victor": 0,
"Gabriel Fallen": float("inf"),
"Maycon": 1,
"Leticia": 1,
"Giovana": 2,
"Lorena": 1,
"Felipe": 1,
"Valentina": 2,
"Juliana": 2,
"Rubens": 2
},
"Maycon": {
"Victor": 1,
"Gabriel Fallen": float("inf"),
"Maycon": 0,
"Leticia": 1,
"Giovana": 2,
"Lorena": 2,
"Felipe": 2,
"Valentina": 3,
"Juliana": 1,
"Rubens": 3
},
"Felipe": {
"Victor": 1,
"Gabriel Fallen": float("inf"),
"Maycon": 2,
"Leticia": 2,
"Giovana": 3,
"Lorena": 1,
"Felipe": 0,
"Valentina": 2,
"Juliana": 3,
"Rubens": 1
}
}
for vertice_inicial, distancias_esperadas in distancias_esperadas_por_v_inicial.items(
):
dict_respostas = grafo.grau_separacao(vertice_inicial)
self.grau_separacao_result_teste(vertice_inicial,
distancias_esperadas,
dict_respostas)
def test_grau_separacao(self):
grafo = Grafo()
grafo.adiciona_vertice("Alice")
grafo.adiciona_vertice("Bob")
grafo.adiciona_vertice("Carol")
grafo.adiciona_vertice("Daniel")
grafo.adiciona_vertice("Elisa")
grafo.adiciona_vertice("Fabio")
grafo.adiciona_vertice("Gabriel")
grafo.adiciona_vertice("Igor")
grafo.adiciona_vertice("Katia")
grafo.adiciona_aresta("Alice", "Carol")
grafo.adiciona_aresta("Alice", "Daniel")
grafo.adiciona_aresta("Alice", "Igor")
grafo.adiciona_aresta("Bob", "Alice")
grafo.adiciona_aresta("Bob", "Carol")
grafo.adiciona_aresta("Carol", "Alice")
grafo.adiciona_aresta("Carol", "Daniel")
grafo.adiciona_aresta("Daniel", "Carol")
grafo.adiciona_aresta("Daniel", "Elisa")
grafo.adiciona_aresta("Elisa", "Gabriel")
grafo.adiciona_aresta("Igor", "Daniel")
grafo.adiciona_aresta("Igor", "Gabriel")
grafo.adiciona_aresta("Gabriel", "Katia")
distancias_esperadas_por_v_inicial = {
"Alice": {
"Alice": 0,
"Bob": float("inf"),
"Carol": 1,
"Daniel": 1,
"Elisa": 2,
"Fabio": float("inf"),
"Gabriel": 2,
"Igor": 1,
"Katia": 3
},
"Bob": {
"Alice": 1,
"Bob": 0,
"Carol": 1,
"Daniel": 2,
"Elisa": 3,
"Fabio": float("inf"),
"Gabriel": 3,
"Igor": 2,
"Katia": 4
},
"Carol": {
"Alice": 1,
"Bob": float("inf"),
"Carol": 0,
"Daniel": 1,
"Elisa": 2,
"Fabio": float("inf"),
"Gabriel": 3,
"Igor": 2,
"Katia": 4
},
"Daniel": {
"Alice": 2,
"Carol": 1,
"Bob": float("inf"),
"Daniel": 0,
"Elisa": 1,
"Fabio": float("inf"),
"Gabriel": 2,
"Igor": 3,
"Katia": 3
}
}
for vertice_inicial, distancias_esperadas in distancias_esperadas_por_v_inicial.items(
):
dict_respostas = grafo.grau_separacao(vertice_inicial)
self.grau_separacao_result_teste(vertice_inicial,
distancias_esperadas,
dict_respostas)
class TestGrafo(unittest.TestCase):
def setUp(self):
self.grafo = Grafo()
self.grafo.adiciona_vertice("A")
self.grafo.adiciona_vertice("B")
self.grafo.adiciona_vertice("C")
self.grafo.adiciona_vertice("D")
self.grafo.adiciona_vertice("E")
self.grafo.adiciona_vertice("F")
self.grafo.adiciona_aresta("A", "B", 4)
self.grafo.adiciona_aresta("B", "D", 2)
self.grafo.adiciona_aresta("B", "C", 4)
self.grafo.adiciona_aresta("B", "E", 1)
self.grafo.adiciona_aresta("C", "D", 1)
self.grafo.adiciona_aresta("D", "C", 10)
self.grafo.adiciona_aresta("D", "A", 1)
self.grafo.adiciona_aresta("E", "C", 1)
self.grafo.adiciona_aresta("E", "A", 1)
def test_distancia_vertice(self):
vertice_a = self.grafo.obtem_vertice("A")
vertice_b = self.grafo.obtem_vertice("B")
distancia_b_10 = DistanciaVerticeOrigem(vertice_b, 10)
distancia_10 = DistanciaVerticeOrigem(vertice_a, 10)
distancia_10_igual = DistanciaVerticeOrigem(vertice_a, 10)
distancia_15 = DistanciaVerticeOrigem(vertice_a, 15)
distancia_9 = DistanciaVerticeOrigem(vertice_a, 9)
self.assertTrue(
distancia_b_10 != distancia_10,
msg=
"Os vertices devem ser os mesmos para que um objeto distancia seja igual ao outro"
)
self.assertTrue(
distancia_10 == distancia_10_igual,
msg=
"Se o vertice e a distancia são iguais, a distancia deveria ser igual"
)
self.assertTrue(
distancia_15 > distancia_10,
msg="Uma distancia de 15 deveria ser maior do que uma distancia 10"
)
self.assertTrue(
distancia_9 < distancia_10,
msg="Uma distancia de 9 deveria ser menor do que uma distancia 10")
def relax_teste(self, distancias: Dict[Vertice, DistanciaVerticeOrigem],
pai: Dict[Vertice, Vertice], vertice: Vertice):
str_msg = "O caminhamento de A para C, passando por E, tem um custo menor (6). "
str_msg += f"O Custo atual é {distancias[vertice].distancia} passando por {pai[vertice].valor}"
self.assertEqual(pai[vertice].valor, "E", msg=str_msg)
self.assertEqual(distancias[vertice].distancia, 6, msg=str_msg)
def test_dijkstra_relax(self):
vertice_a = self.grafo.obtem_vertice("A")
vertice_c = self.grafo.obtem_vertice("C")
vertice_b = self.grafo.obtem_vertice("B")
vertice_e = self.grafo.obtem_vertice("E")
heap = MinHeap()
#caminhamentos considrando no A como origem
distancias = {
vertice_c: DistanciaVerticeOrigem(vertice_c, 8),
vertice_b: DistanciaVerticeOrigem(vertice_b, 4),
vertice_e: DistanciaVerticeOrigem(vertice_e, 5)
}
pai = {
vertice_a: None,
vertice_b: vertice_a,
vertice_e: vertice_b,
vertice_c: vertice_b
}
self.grafo.dijkstra_relax(heap, vertice_e, vertice_c, distancias, pai)
#verifica se as distancias e o caminho foram modificadas apropriadamente
#Fazemos o caminhamento de A para C, passando por E, em um custo menor (6)
self.relax_teste(distancias, pai, vertice_c)
self.assertEqual(
len(heap.arr_heap), 2,
"Sempre quando seja alterado a distancia deve-se adicionar no heap esta distancia"
)
self.assertEqual(
heap.arr_heap[1].vertice.valor, "C",
"O vértice adicionado no heap deveria ser o vértice C")
#depois de modificado, o caminho de A para C passando por B não pode modificar o menor
#caminho encontrado até então
self.grafo.dijkstra_relax(heap, vertice_e, vertice_c, distancias, pai)
self.relax_teste(distancias, pai, vertice_c)
self.assertEqual(len(heap.arr_heap), 2,
"O heap não deveria ser modificado neste caso")
def check_respostas(self, v_origem: str, str_resposta: str,
dict_esperado: Dict, dict_respostas: Dict):
lst_vertices_respostas = set(
[vertice.valor for vertice in dict_respostas.keys()])
lst_vertices_esperado = set(dict_esperado.keys())
set_faltou = lst_vertices_esperado - lst_vertices_respostas
set_vert_invalidas = lst_vertices_respostas - lst_vertices_esperado
self.assertTrue(
len(set_faltou) == 0,
msg=
f"Faltou a resposta ({str_resposta}) os seguintes vertices: {set_faltou} - vértice origem: {v_origem}"
)
self.assertTrue(
len(set_vert_invalidas) == 0,
msg=
f"Os vértices {set_vert_invalidas} não deveriam estar inclusos no resultado ({str_resposta}) - vértice origem: {v_origem}"
)
def dijkstra_result_teste(self, valor_vertice_inicial: str,
dist_esperada: Dict[str, int],
resposta_distancia: Dict[Vertice,
DistanciaVerticeOrigem],
pai_esperado: Dict[Vertice, str],
resposta_pai: Dict[Vertice, Vertice]):
self.check_respostas(valor_vertice_inicial, "distancias",
dist_esperada, resposta_distancia)
self.check_respostas(valor_vertice_inicial, "pai", pai_esperado,
resposta_pai)
for vertice, distancia in resposta_distancia.items():
vertice_valor = vertice.valor
self.assertEqual(
dist_esperada[vertice_valor], distancia.distancia,
f"A distancia entre {valor_vertice_inicial} e {vertice_valor} deveria ser {dist_esperada[vertice_valor]} e foi {distancia.distancia}"
)
pai_resposta = resposta_pai[vertice].valor if resposta_pai[
vertice] is not None else None
self.assertEqual(
pai_esperado[vertice_valor], pai_resposta,
f"No caminho mínimo de {valor_vertice_inicial} para {vertice_valor}, o vértice pai de {vertice_valor} é {pai_esperado[vertice_valor]} e não a {pai_resposta}"
)
def test_dijkstra(self):
distancias_esperadas_por_v_inicial = {
"C": {
"A": 2,
"B": 6,
"C": 0,
"D": 1,
"E": 7,
"F": float("inf"),
}
}
pai_esperado_por_v_inicial = {
"A": {
"A": None,
"B": "A",
"C": "E",
"D": "B",
"E": "B",
"F": None
},
"B": {
"A": "E",
"B": None,
"C": "E",
"D": "B",
"E": "B",
"F": None
},
"C": {
"A": "D",
"B": "A",
"C": None,
"D": "C",
"E": "B",
"F": None
},
"D": {
"A": "D",
"B": "A",
"C": "E",
"D": None,
"E": "B",
"F": None
}
}
for vertice_inicial, distancias_esperadas in distancias_esperadas_por_v_inicial.items(
):
pai_esperado = pai_esperado_por_v_inicial[vertice_inicial]
dict_resp_distancias, dict_resp_pai = self.grafo.dijkstra(
vertice_inicial)
self.dijkstra_result_teste(vertice_inicial, distancias_esperadas,
dict_resp_distancias, pai_esperado,
dict_resp_pai)
# nome_arquivo = input("Digite o caminho para o arquivo: ")
nome_arquivo = "/home/lhleonardo/Área de Trabalho/atividades-grafos/exercicios/lista-1/ex2-domino/arquivo.txt"
arquivo = open(nome_arquivo, "r")
quantidade = int(arquivo.readline())
for i in range(1, 7):
grafo.adiciona_vertice(i)
for linha in arquivo:
linha = linha.split()
u = int(linha[0])
v = int(linha[1])
grafo.adiciona_aresta(u, v)
try:
resultado = verifica_sequencia(grafo)
indice = 0
print("Sequência de peças: ", end="")
while indice < len(resultado) - 1:
print("(", end="")
print(resultado[indice], "-", resultado[indice + 1], end="")
print(")", end="")
if indice is not (len(resultado) - 2):
print(" -> ", end="")
indice = indice + 1
print()
except Exception as ex: