class TestGrafo(unittest.TestCase):
def setUp(self):
# Grafo de teste pessoal
self.g_ac = Grafo(["A", 'B', 'C', 'E', 'F'])
lis = ['A-B', 'A-C', 'B-E', 'C-F', 'E-F']
for i in lis:
self.g_ac.adicionaAresta(i)
# Grafo da Paraíba
self.g_p = Grafo(['J', 'C', 'E', 'P', 'M', 'T', 'Z'])
#{'a1':'J-C', 'a2':'C-E', 'a3':'C-E', 'a4':'C-P', 'a5':'C-P', 'a6':'C-M', 'a7':'C-T', 'a8':'M-T', 'a9':'T-Z'}
self.g_p.adicionaAresta('J-C')
self.g_p.adicionaAresta('C-E')
self.g_p.adicionaAresta('C-E')
self.g_p.adicionaAresta('C-P')
self.g_p.adicionaAresta('C-P')
self.g_p.adicionaAresta('C-M')
self.g_p.adicionaAresta('C-T')
self.g_p.adicionaAresta('M-T')
self.g_p.adicionaAresta('T-Z')
# Grafo da Paraíba sem arestas paralelas
self.g_p_sem_paralelas = Grafo(['J', 'C', 'E', 'P', 'M', 'T', 'Z'])
self.g_p_sem_paralelas.adicionaAresta('J-C')
self.g_p_sem_paralelas.adicionaAresta('C-E')
self.g_p_sem_paralelas.adicionaAresta('C-P')
self.g_p_sem_paralelas.adicionaAresta('C-M')
self.g_p_sem_paralelas.adicionaAresta('C-T')
self.g_p_sem_paralelas.adicionaAresta('M-T')
self.g_p_sem_paralelas.adicionaAresta('T-Z')
# Grafos completos
#self.g_c = Grafo(['J', 'C', 'E', 'P'], {'a1':'J-C', 'a3':'J-E', 'a4':'J-P', 'a6':'C-E', 'a7':'C-P', 'a8':'E-P'})
self.g_c = Grafo(['J', 'C', 'E', 'P'])
self.g_c.adicionaAresta('J-C')
self.g_c.adicionaAresta('J-E')
self.g_c.adicionaAresta('J-P')
self.g_c.adicionaAresta('C-E')
self.g_c.adicionaAresta('C-P')
self.g_c.adicionaAresta('E-P')
self.g_c3 = Grafo(['J'])
# Grafos com laco
#self.g_l1 = Grafo(['A', 'B', 'C', 'D'], {'a1':'A-A', 'a2':'B-A', 'a3':'A-A'})
self.g_l1 = Grafo(['A', 'B', 'C', 'D'])
self.g_l1.adicionaAresta('A-A')
self.g_l1.adicionaAresta('A-A')
self.g_l1.adicionaAresta('B-A')
#self.g_l2 = Grafo(['A', 'B', 'C', 'D'], {'a1':'A-B', 'a2':'B-B', 'a3':'B-A'})
self.g_l2 = Grafo(['A', 'B', 'C', 'D'])
self.g_l2.adicionaAresta('A-B')
self.g_l2.adicionaAresta('B-B')
self.g_l2.adicionaAresta('B-A')
#self.g_l3 = Grafo(['A', 'B', 'C', 'D'], {'a1':'C-A', 'a2':'C-C', 'a3':'D-D'})
self.g_l3 = Grafo(['A', 'B', 'C', 'D'])
self.g_l3.adicionaAresta('C-A')
self.g_l3.adicionaAresta('C-C')
self.g_l3.adicionaAresta('D-D')
#self.g_l4 = Grafo(['D'], {'a2':'D-D'})
self.g_l4 = Grafo(['D'])
self.g_l4.adicionaAresta('D-D')
#self.g_l5 = Grafo(['C', 'D'], {'a2':'D-C', 'a3':'C-C'})
self.g_l5 = Grafo(['C', 'D'])
self.g_l5.adicionaAresta('D-C')
self.g_l5.adicionaAresta('C-C')
def test_print(self):
print("g_p")
print(self.g_p)
print("g_p_sem_paralelas")
print(self.g_p_sem_paralelas)
print("g_c")
print(self.g_c)
print("g_c3")
print(self.g_c3)
print("g_11")
print(self.g_l1)
print("g_12")
print(self.g_l2)
print("g_13")
print(self.g_l3)
print("g_14")
print(self.g_l4)
print("g_15")
print(self.g_l5)
def test_vertices_nao_adjacentes(self):
self.assertEqual(self.g_p.vertices_nao_adjacentes(), [
'J-J', 'J-E', 'J-P', 'J-M', 'J-T', 'J-Z', 'C-C', 'C-Z', 'E-E',
'E-P', 'E-M', 'E-T', 'E-Z', 'P-P', 'P-M', 'P-T', 'P-Z', 'M-M',
'M-Z', 'T-T', 'Z-Z'
])
self.assertEqual(self.g_c.vertices_nao_adjacentes(),
['J-J', 'C-C', 'E-E', 'P-P'])
self.assertEqual(self.g_c3.vertices_nao_adjacentes(), ['J-J'])
def test_ha_laco(self):
self.assertFalse(self.g_p.ha_laco())
self.assertFalse(self.g_p_sem_paralelas.ha_laco())
self.assertTrue(self.g_l1.ha_laco())
self.assertTrue(self.g_l2.ha_laco())
self.assertTrue(self.g_l3.ha_laco())
self.assertTrue(self.g_l4.ha_laco())
self.assertTrue(self.g_l5.ha_laco())
def test_grau(self):
# Paraíba
self.assertEqual(self.g_p.grau('J'), 1)
self.assertEqual(self.g_p.grau('C'), 7)
self.assertEqual(self.g_p.grau('E'), 2)
self.assertEqual(self.g_p.grau('P'), 2)
self.assertEqual(self.g_p.grau('M'), 2)
self.assertEqual(self.g_p.grau('T'), 3)
self.assertEqual(self.g_p.grau('Z'), 1)
# Completos
self.assertEqual(self.g_c.grau('J'), 3)
self.assertEqual(self.g_c.grau('C'), 3)
self.assertEqual(self.g_c.grau('E'), 3)
self.assertEqual(self.g_c.grau('P'), 3)
# Com laço. Lembrando que cada laço conta uma única vez por vértice para cálculo do grau
self.assertEqual(self.g_l1.grau('A'), 3)
self.assertEqual(self.g_l2.grau('B'), 3)
self.assertEqual(self.g_l4.grau('D'), 1)
def test_arestas_ha_paralelas(self):
self.assertTrue(self.g_p.ha_paralelas())
self.assertFalse(self.g_p_sem_paralelas.ha_paralelas())
self.assertFalse(self.g_c.ha_paralelas())
self.assertFalse(self.g_c3.ha_paralelas())
self.assertTrue(self.g_l1.ha_paralelas())
def test_arestas_sobre_vertice(self):
#{'a1': 'J-C', 'a2': 'C-E', 'a3': 'C-E', 'a4': 'C-P', 'a5': 'C-P', 'a6': 'C-M', 'a7': 'C-T', 'a8': 'M-T',
# 'a9': 'T-Z'}
self.assertEqual(set(self.g_p.arestas_sobre_vertice('J')),
set(['J-C']))
self.assertEqual(
set(self.g_p.arestas_sobre_vertice('C')),
set(['J-C', 'C-E', 'C-E', 'C-P', 'C-P', 'C-M', 'C-T']))
self.assertEqual(set(self.g_p.arestas_sobre_vertice('M')),
set(['C-M', 'M-T']))
def test_eh_completo(self):
self.assertFalse(self.g_p.eh_completo())
self.assertFalse((self.g_p_sem_paralelas.eh_completo()))
self.assertTrue((self.g_c.eh_completo()))
#self.assertTrue((self.g_c2.eh_completo()))
self.assertTrue((self.g_c3.eh_completo()))
self.assertFalse((self.g_l1.eh_completo()))
self.assertFalse((self.g_l2.eh_completo()))
self.assertFalse((self.g_l3.eh_completo()))
self.assertTrue((self.g_l4.eh_completo()))
self.assertTrue((self.g_l5.eh_completo()))
def test_comprimento_de_tamanho_n(self):
self.assertTrue(self.g_p.comprimento_de_tamanho_n(1))
self.assertTrue(self.g_p_sem_paralelas.comprimento_de_tamanho_n(2))
self.assertTrue(self.g_c.comprimento_de_tamanho_n(3))
self.assertFalse(self.g_c3.comprimento_de_tamanho_n(5))
self.assertFalse(self.g_l1.comprimento_de_tamanho_n(6))
self.assertFalse(self.g_l2.comprimento_de_tamanho_n(7))
self.assertFalse(self.g_l3.comprimento_de_tamanho_n(8))
self.assertFalse(self.g_l4.comprimento_de_tamanho_n(9))
def test_ha_ciclo(self):
self.assertEqual(self.g_p.ha_ciclo(), ["C", "a2", "E", "a3", "C"])
self.assertEqual(self.g_p_sem_paralelas.ha_ciclo(),
["C", "a4", "M", "a6", "T", "a5", "C"])
self.assertEqual(self.g_c.ha_ciclo(),
["C", "a4", "E", "a6", "P", "a5", "C"])
self.assertFalse(self.g_c3.ha_ciclo())
self.assertEqual(self.g_l1.ha_ciclo(), ["A", "a1", "A"])
self.assertEqual(self.g_l2.ha_ciclo(), ["A", "a1", "B", "a2", "A"])
self.assertEqual(self.g_l3.ha_ciclo(), ["C", "a2", "C"])
self.assertEqual(self.g_l4.ha_ciclo(), ["D", "a1", "D"])
self.assertEqual(self.g_l5.ha_ciclo(), ["C", "a1", "C"])
def test_eh_conexo(self):
self.assertTrue(self.g_p.eh_conexo())
self.assertTrue(self.g_p_sem_paralelas.eh_conexo())
self.assertTrue(self.g_c.eh_conexo())
self.assertTrue(self.g_c3.eh_conexo())
self.assertFalse(self.g_l1.eh_conexo())
self.assertFalse(self.g_l2.eh_conexo())
self.assertFalse(self.g_l3.eh_conexo())
self.assertTrue(self.g_l4.eh_conexo())
self.assertTrue(self.g_l5.eh_conexo())
class TestGrafo(unittest.TestCase):
def setUp(self):
# Grafo da Paraíba
self.g_p = Grafo(['J', 'C', 'E', 'P', 'M', 'T', 'Z'])
# {'a1':'J-C', 'a2':'C-E', 'a3':'C-E', 'a4':'C-P', 'a5':'C-P', 'a6':'C-M', 'a7':'C-T', 'a8':'M-T', 'a9':'T-Z'}
self.g_p.adicionaAresta('J-C')
self.g_p.adicionaAresta('C-E')
self.g_p.adicionaAresta('C-E')
self.g_p.adicionaAresta('C-P')
self.g_p.adicionaAresta('C-P')
self.g_p.adicionaAresta('C-M')
self.g_p.adicionaAresta('C-T')
self.g_p.adicionaAresta('M-T')
self.g_p.adicionaAresta('T-Z')
# Grafo da Paraíba sem arestas paralelas
self.g_p_sem_paralelas = Grafo(['J', 'C', 'E', 'P', 'M', 'T', 'Z'])
self.g_p_sem_paralelas.adicionaAresta('J-C')
self.g_p_sem_paralelas.adicionaAresta('C-E')
self.g_p_sem_paralelas.adicionaAresta('C-P')
self.g_p_sem_paralelas.adicionaAresta('C-M')
self.g_p_sem_paralelas.adicionaAresta('C-T')
self.g_p_sem_paralelas.adicionaAresta('M-T')
self.g_p_sem_paralelas.adicionaAresta('T-Z')
# Grafos completos
# self.g_c = Grafo(['J', 'C', 'E', 'P'], {'a1':'J-C', 'a3':'J-E', 'a4':'J-P', 'a6':'C-E', 'a7':'C-P', 'a8':'E-P'})
self.g_c = Grafo(['J', 'C', 'E', 'P'])
self.g_c.adicionaAresta('J-C')
self.g_c.adicionaAresta('J-E')
self.g_c.adicionaAresta('J-P')
self.g_c.adicionaAresta('C-E')
self.g_c.adicionaAresta('C-P')
self.g_c.adicionaAresta('E-P')
self.g_c3 = Grafo(['J'])
# Grafos com laco
# self.g_l1 = Grafo(['A', 'B', 'C', 'D'], {'a1':'A-A', 'a2':'B-A', 'a3':'A-A'})
self.g_l1 = Grafo(['A', 'B', 'C', 'D'])
self.g_l1.adicionaAresta('A-A')
self.g_l1.adicionaAresta('A-A')
self.g_l1.adicionaAresta('B-A')
# self.g_l2 = Grafo(['A', 'B', 'C', 'D'], {'a1':'A-B', 'a2':'B-B', 'a3':'B-A'})
self.g_l2 = Grafo(['A', 'B', 'C', 'D'])
self.g_l2.adicionaAresta('A-B')
self.g_l2.adicionaAresta('B-B')
self.g_l2.adicionaAresta('B-A')
# self.g_l3 = Grafo(['A', 'B', 'C', 'D'], {'a1':'C-A', 'a2':'C-C', 'a3':'D-D'})
self.g_l3 = Grafo(['A', 'B', 'C', 'D'])
self.g_l3.adicionaAresta('C-A')
self.g_l3.adicionaAresta('C-C')
self.g_l3.adicionaAresta('D-D')
# self.g_l4 = Grafo(['D'], {'a2':'D-D'})
self.g_l4 = Grafo(['D'])
self.g_l4.adicionaAresta('D-D')
# self.g_l5 = Grafo(['C', 'D'], {'a2':'D-C', 'a3':'C-C'})
self.g_l5 = Grafo(['C', 'D'])
self.g_l5.adicionaAresta('D-C')
self.g_l5.adicionaAresta('C-C')
# Grafos criados por nós
self.g_1 = Grafo(['A', 'B', 'C', 'D', 'E', 'F', 'G'])
self.g_1.adicionaAresta('A-B')
self.g_1.adicionaAresta('B-C')
self.g_1.adicionaAresta('C-D')
self.g_1.adicionaAresta('D-E')
self.g_1.adicionaAresta('E-F')
self.g_1.adicionaAresta('F-G')
self.g_1.adicionaAresta('G-E')
self.g_1.adicionaAresta('E-C')
self.g_1.adicionaAresta('C-A')
self.g_2 = Grafo(['1', '2', '3', '4', '5', '6', '7', '8', '9'])
self.g_2.adicionaAresta('1-2')
self.g_2.adicionaAresta('1-5')
self.g_2.adicionaAresta('1-4')
self.g_2.adicionaAresta('4-5')
self.g_2.adicionaAresta('5-2')
self.g_2.adicionaAresta('2-3')
self.g_2.adicionaAresta('3-9')
self.g_2.adicionaAresta('6-8')
self.g_2.adicionaAresta('8-7')
self.g_2.adicionaAresta('7-6')
self.g_3 = Grafo(['A', 'B', 'C', 'D', 'E', 'F'])
self.g_3.adicionaAresta('A-B')
self.g_3.adicionaAresta('A-C')
self.g_3.adicionaAresta('B-D')
self.g_3.adicionaAresta('B-E')
self.g_3.adicionaAresta('C-E')
self.g_3.adicionaAresta('C-F')
self.g_3.adicionaAresta('D-E')
self.g_3.adicionaAresta('E-F')
self.g_3.adicionaAresta('B-C')
self.g_4 = Grafo(['A', 'B', 'C', 'D', 'E', 'F'])
self.g_4.adicionaAresta('A-D')
self.g_4.adicionaAresta('A-B')
self.g_4.adicionaAresta('C-A')
self.g_4.adicionaAresta('C-F')
self.g_4.adicionaAresta('C-D')
self.g_4.adicionaAresta('D-F')
self.g_4.adicionaAresta('B-D')
self.g_4.adicionaAresta('E-A')
self.g_4.adicionaAresta('E-C')
self.g_5 = Grafo(['A', 'B', 'C', 'D', 'E'])
self.g_5.adicionaAresta('A-B')
self.g_5.adicionaAresta('A-C')
self.g_5.adicionaAresta('A-D')
self.g_5.adicionaAresta('C-D')
self.g_5.adicionaAresta('B-D')
self.g_5.adicionaAresta('B-E')
self.g_5.adicionaAresta('D-E')
self.g_7 = Grafo(['A', 'B', 'C', 'D', 'E'])
self.g_7.adicionaAresta('A-B')
self.g_7.adicionaAresta('A-C')
self.g_7.adicionaAresta('A-D')
self.g_7.adicionaAresta('B-D')
self.g_7.adicionaAresta('D-C')
self.g_7.adicionaAresta('B-E')
self.g_7.adicionaAresta('C-E')
# Grafos Dijkstra
self.g_D1 = Grafo([], [])
for i in [
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L',
'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g'
]:
self.g_D1.adicionaVertice(i)
for i in [
'A-B', 'A-M', 'A-L', 'B-C', 'B-D', 'C-V', 'V-B', 'D-E', 'E-F',
'E-X', 'F-G', 'G-g', 'G-H', 'H-I', 'I-J', 'J-K', 'J-a', 'K-a',
'M-N', 'N-W', 'N-V', 'N-P', 'V-W', 'W-D', 'W-U', 'U-Y', 'U-T',
'U-X', 'X-Y', 'X-c', 'c-d', 'c-b', 'd-e', 'd-J', 'e-X', 'Y-Z',
'Y-F', 'Z-e', 'Z-f', 'Z-g', 'L-M', 'L-O', 'O-N', 'O-Q', 'Q-S',
'S-T', 'T-X', 'P-R', 'R-X'
]:
self.g_D1.adicionaAresta(i)
def test_vertices_nao_adjacentes(self):
self.assertEqual(self.g_p.vertices_nao_adjacentes(), [
'J-J', 'J-E', 'J-P', 'J-M', 'J-T', 'J-Z', 'C-C', 'C-Z', 'E-E',
'E-P', 'E-M', 'E-T', 'E-Z', 'P-P', 'P-M', 'P-T', 'P-Z', 'M-M',
'M-Z', 'T-T', 'Z-Z'
])
self.assertEqual(self.g_c.vertices_nao_adjacentes(),
['J-J', 'C-C', 'E-E', 'P-P'])
self.assertEqual(self.g_c3.vertices_nao_adjacentes(), ['J-J'])
def test_ha_laco(self):
self.assertFalse(self.g_p.ha_laco())
self.assertFalse(self.g_p_sem_paralelas.ha_laco())
self.assertTrue(self.g_l1.ha_laco())
self.assertTrue(self.g_l2.ha_laco())
self.assertTrue(self.g_l3.ha_laco())
self.assertTrue(self.g_l4.ha_laco())
self.assertTrue(self.g_l5.ha_laco())
def test_grau(self):
# Paraíba
self.assertEqual(self.g_p.grau('J'), 1)
self.assertEqual(self.g_p.grau('C'), 7)
self.assertEqual(self.g_p.grau('E'), 2)
self.assertEqual(self.g_p.grau('P'), 2)
self.assertEqual(self.g_p.grau('M'), 2)
self.assertEqual(self.g_p.grau('T'), 3)
self.assertEqual(self.g_p.grau('Z'), 1)
# Completos
self.assertEqual(self.g_c.grau('J'), 3)
self.assertEqual(self.g_c.grau('C'), 3)
self.assertEqual(self.g_c.grau('E'), 3)
self.assertEqual(self.g_c.grau('P'), 3)
# Com laço. Lembrando que cada laço conta uma única vez por vértice para cálculo do grau
self.assertEqual(self.g_l1.grau('A'), 3)
self.assertEqual(self.g_l2.grau('B'), 3)
self.assertEqual(self.g_l4.grau('D'), 1)
def test_arestas_ha_paralelas(self):
self.assertTrue(self.g_p.ha_paralelas())
self.assertFalse(self.g_p_sem_paralelas.ha_paralelas())
self.assertFalse(self.g_c.ha_paralelas())
self.assertFalse(self.g_c3.ha_paralelas())
self.assertTrue(self.g_l1.ha_paralelas())
def test_arestas_sobre_vertice(self):
# {'a1': 'J-C', 'a2': 'C-E', 'a3': 'C-E', 'a4': 'C-P', 'a5': 'C-P', 'a6': 'C-M', 'a7': 'C-T', 'a8': 'M-T',
# 'a9': 'T-Z'}
self.assertEqual(set(self.g_p.arestas_sobre_vertice('J')),
set(['J-C']))
self.assertEqual(
set(self.g_p.arestas_sobre_vertice('C')),
set(['J-C', 'C-E', 'C-E', 'C-P', 'C-P', 'C-M', 'C-T']))
self.assertEqual(set(self.g_p.arestas_sobre_vertice('M')),
set(['C-M', 'M-T']))
def test_eh_completo(self):
self.assertFalse(self.g_p.eh_completo())
self.assertFalse((self.g_p_sem_paralelas.eh_completo()))
self.assertTrue((self.g_c.eh_completo()))
# self.assertTrue((self.g_c2.eh_completo())) não existe referência.
self.assertTrue((self.g_c3.eh_completo()))
self.assertFalse((self.g_l1.eh_completo()))
self.assertFalse((self.g_l2.eh_completo()))
self.assertFalse((self.g_l3.eh_completo()))
self.assertTrue((self.g_l4.eh_completo()))
self.assertTrue((self.g_l5.eh_completo()))
def test_caminhoEuleriano(self):
self.assertFalse(self.g_p.caminhoEuleriano())
self.assertTrue(self.g_1.caminhoEuleriano())
self.assertFalse(self.g_2.caminhoEuleriano())
self.assertTrue(self.g_3.caminhoEuleriano())
self.assertTrue(self.g_4.caminhoEuleriano())
self.assertTrue(self.g_5.caminhoEuleriano())
self.assertFalse(self.g_p_sem_paralelas.caminhoEuleriano())
self.assertFalse(self.g_c.caminhoEuleriano())
self.assertTrue(self.g_l1.caminhoEuleriano())
self.assertFalse(self.g_l2.caminhoEuleriano())
self.assertTrue(self.g_l3.caminhoEuleriano())
def test_fleury(self):
self.assertEqual(self.g_1.fleury(),
['A', 'B', 'C', 'D', 'E', 'F', 'G', 'E', 'C', 'A'])
self.assertFalse(self.g_2.fleury())
self.assertEqual(self.g_3.fleury(),
['A', 'B', 'C', 'E', 'D', 'B', 'E', 'F', 'C', 'A'])
self.assertEqual(self.g_4.fleury(),
['B', 'A', 'C', 'D', 'F', 'C', 'E', 'A', 'D', 'B'])
self.assertEqual(self.g_5.fleury(),
['A', 'B', 'D', 'C', 'A', 'D', 'E', 'B'])
self.assertFalse(self.g_p.fleury())
self.assertFalse(self.g_p_sem_paralelas.fleury())
self.assertFalse(self.g_c.fleury())
self.assertEqual(self.g_l1.fleury(), ['A', 'B'])
self.assertFalse(self.g_l2.fleury())
self.assertEqual(self.g_l3.fleury(), ['A'])
def test_ciclo_hamiltoniano(self):
self.assertFalse(self.g_1.ciclo_hamiltoniano())
self.assertFalse(self.g_2.ciclo_hamiltoniano())
self.assertEqual(self.g_3.ciclo_hamiltoniano(),
['A', 'B', 'D', 'E', 'F', 'C', 'A'])
self.assertEqual(self.g_4.ciclo_hamiltoniano(),
['A', 'B', 'D', 'F', 'C', 'E', 'A'])
self.assertEqual(self.g_5.ciclo_hamiltoniano(),
['A', 'B', 'E', 'D', 'C', 'A'])
self.assertEqual(self.g_7.ciclo_hamiltoniano(),
['A', 'B', 'E', 'C', 'D', 'A'])
self.assertEqual(self.g_c.ciclo_hamiltoniano(),
['J', 'C', 'E', 'P', 'J'])
self.assertFalse(self.g_l1.ciclo_hamiltoniano())
self.assertFalse(self.g_l2.ciclo_hamiltoniano())
self.assertFalse(self.g_l3.ciclo_hamiltoniano())
def test_dijkstra(self):
self.assertEqual(
self.g_D1.dijkstra('A', 'a', ['Q', 'X', 'G', 'I', 'J'], 3, 4),
['A', 'L', 'O', 'Q', 'S', 'T', 'X', 'c', 'd', 'J', 'a'])
self.assertEqual(self.g_D1.dijkstra('A', 'a', ['G', 'I'], 5, 5),
['A', 'B', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'a'])
self.assertEqual(self.g_p.dijkstra('J', 'Z', ['M'], 2, 2),
['J', 'C', 'M', 'T', 'Z'])
self.assertEqual(self.g_7.dijkstra('A', 'E', ['D'], 1, 2),
['A', 'D', 'B', 'E'])
self.assertEqual(self.g_4.dijkstra('F', 'B', ['C'], 1, 2),
['F', 'C', 'A', 'B'])
self.assertEqual(self.g_1.dijkstra('B', 'G', ['A', 'D'], 1, 2),
['B', 'A', 'C', 'E', 'G'])
class TestGrafo(unittest.TestCase):
def setUp(self):
# Grafo da Paraíba
self.g_p = Grafo(['J', 'C', 'E', 'P', 'M', 'T', 'Z'])
#{'a1':'J-C', 'a2':'C-E', 'a3':'C-E', 'a4':'C-P', 'a5':'C-P', 'a6':'C-M', 'a7':'C-T', 'a8':'M-T', 'a9':'T-Z'}
self.g_p.adicionaAresta('J-C')
self.g_p.adicionaAresta('C-E')
self.g_p.adicionaAresta('C-E')
self.g_p.adicionaAresta('C-P')
self.g_p.adicionaAresta('C-P')
self.g_p.adicionaAresta('C-M')
self.g_p.adicionaAresta('C-T')
self.g_p.adicionaAresta('M-T')
self.g_p.adicionaAresta('T-Z')
# Grafo da Paraíba sem arestas paralelas
self.g_p_sem_paralelas = Grafo(['J', 'C', 'E', 'P', 'M', 'T', 'Z'])
self.g_p_sem_paralelas.adicionaAresta('J-C')
self.g_p_sem_paralelas.adicionaAresta('C-E')
self.g_p_sem_paralelas.adicionaAresta('C-P')
self.g_p_sem_paralelas.adicionaAresta('C-M')
self.g_p_sem_paralelas.adicionaAresta('C-T')
self.g_p_sem_paralelas.adicionaAresta('M-T')
self.g_p_sem_paralelas.adicionaAresta('T-Z')
# Grafos completos
#self.g_c = Grafo(['J', 'C', 'E', 'P'], {'a1':'J-C', 'a3':'J-E', 'a4':'J-P', 'a6':'C-E', 'a7':'C-P', 'a8':'E-P'})
self.g_c = Grafo(['J', 'C', 'E', 'P'])
self.g_c.adicionaAresta('J-C')
self.g_c.adicionaAresta('J-E')
self.g_c.adicionaAresta('J-P')
self.g_c.adicionaAresta('C-E')
self.g_c.adicionaAresta('C-P')
self.g_c.adicionaAresta('E-P')
self.g_c3 = Grafo(['J'])
# Grafos com laco
#self.g_l1 = Grafo(['A', 'B', 'C', 'D'], {'a1':'A-A', 'a2':'B-A', 'a3':'A-A'})
self.g_l1 = Grafo(['A', 'B', 'C', 'D'])
self.g_l1.adicionaAresta('A-A')
self.g_l1.adicionaAresta('A-A')
self.g_l1.adicionaAresta('B-A')
#self.g_l2 = Grafo(['A', 'B', 'C', 'D'], {'a1':'A-B', 'a2':'B-B', 'a3':'B-A'})
self.g_l2 = Grafo(['A', 'B', 'C', 'D'])
self.g_l2.adicionaAresta('A-B')
self.g_l2.adicionaAresta('B-B')
self.g_l2.adicionaAresta('B-A')
#self.g_l3 = Grafo(['A', 'B', 'C', 'D'], {'a1':'C-A', 'a2':'C-C', 'a3':'D-D'})
self.g_l3 = Grafo(['A', 'B', 'C', 'D'])
self.g_l3.adicionaAresta('C-A')
self.g_l3.adicionaAresta('C-C')
self.g_l3.adicionaAresta('D-D')
#self.g_l4 = Grafo(['D'], {'a2':'D-D'})
self.g_l4 = Grafo(['D'])
self.g_l4.adicionaAresta('D-D')
#self.g_l5 = Grafo(['C', 'D'], {'a2':'D-C', 'a3':'C-C'})
self.g_l5 = Grafo(['C', 'D'])
self.g_l5.adicionaAresta('D-C')
self.g_l5.adicionaAresta('C-C')
def test_vertices_nao_adjacentes(self):
self.assertEqual(self.g_p.vertices_nao_adjacentes(), [
'J-J', 'J-E', 'J-P', 'J-M', 'J-T', 'J-Z', 'C-C', 'C-Z', 'E-E',
'E-P', 'E-M', 'E-T', 'E-Z', 'P-P', 'P-M', 'P-T', 'P-Z', 'M-M',
'M-Z', 'T-T', 'Z-Z'
])
self.assertEqual(self.g_c.vertices_nao_adjacentes(),
['J-J', 'C-C', 'E-E', 'P-P'])
self.assertEqual(self.g_c3.vertices_nao_adjacentes(), ['J-J'])
def test_ha_laco(self):
self.assertFalse(self.g_p.ha_laco())
self.assertFalse(self.g_p_sem_paralelas.ha_laco())
self.assertTrue(self.g_l1.ha_laco())
self.assertTrue(self.g_l2.ha_laco())
self.assertTrue(self.g_l3.ha_laco())
self.assertTrue(self.g_l4.ha_laco())
self.assertTrue(self.g_l5.ha_laco())
def test_grau(self):
# Paraíba
self.assertEqual(self.g_p.grau('J'), 1)
self.assertEqual(self.g_p.grau('C'), 7)
self.assertEqual(self.g_p.grau('E'), 2)
self.assertEqual(self.g_p.grau('P'), 2)
self.assertEqual(self.g_p.grau('M'), 2)
self.assertEqual(self.g_p.grau('T'), 3)
self.assertEqual(self.g_p.grau('Z'), 1)
# Completos
self.assertEqual(self.g_c.grau('J'), 3)
self.assertEqual(self.g_c.grau('C'), 3)
self.assertEqual(self.g_c.grau('E'), 3)
self.assertEqual(self.g_c.grau('P'), 3)
# Com laço. Lembrando que cada laço conta uma única vez por vértice para cálculo do grau
self.assertEqual(self.g_l1.grau('A'), 3)
self.assertEqual(self.g_l2.grau('B'), 3)
self.assertEqual(self.g_l4.grau('D'), 1)
def test_arestas_ha_paralelas(self):
self.assertTrue(self.g_p.ha_paralelas())
self.assertFalse(self.g_p_sem_paralelas.ha_paralelas())
self.assertFalse(self.g_c.ha_paralelas())
self.assertFalse(self.g_c3.ha_paralelas())
self.assertTrue(self.g_l1.ha_paralelas())
def test_arestas_sobre_vertice(self):
#{'a1': 'J-C', 'a2': 'C-E', 'a3': 'C-E', 'a4': 'C-P', 'a5': 'C-P', 'a6': 'C-M', 'a7': 'C-T', 'a8': 'M-T',
# 'a9': 'T-Z'}
self.assertEqual(set(self.g_p.arestas_sobre_vertice('J')),
set(['J-C']))
self.assertEqual(
set(self.g_p.arestas_sobre_vertice('C')),
set(['J-C', 'C-E', 'C-E', 'C-P', 'C-P', 'C-M', 'C-T']))
self.assertEqual(set(self.g_p.arestas_sobre_vertice('M')),
set(['C-M', 'M-T']))
def test_eh_completo(self):
self.assertFalse(self.g_p.eh_completo())
self.assertFalse((self.g_p_sem_paralelas.eh_completo()))
self.assertTrue((self.g_c.eh_completo()))
self.assertTrue((self.g_c3.eh_completo()))
self.assertFalse((self.g_l1.eh_completo()))
self.assertFalse((self.g_l2.eh_completo()))
self.assertFalse((self.g_l3.eh_completo()))
self.assertTrue((self.g_l4.eh_completo()))
self.assertTrue((self.g_l5.eh_completo()))
# g_p.adicionaAresta('C-P')
# g_p.adicionaAresta('C-P')
# g_p.adicionaAresta('C-M')
# g_p.adicionaAresta('C-T')
# g_p.adicionaAresta('M-T')
# g_p.adicionaAresta('T-Z')
# #g_p.adicionaAresta('Z-Z')
#
# g_p = Grafo(['J', 'C', 'E', 'P'])
# g_p.adicionaAresta('J-C')
# g_p.adicionaAresta('J-E')
# g_p.adicionaAresta('J-P')
# g_p.adicionaAresta('C-E')
# g_p.adicionaAresta('C-P')
# g_p.adicionaAresta('E-P')
g_p = Grafo(['C', 'D'])
g_p.adicionaAresta('D-C')
g_p.adicionaAresta('C-C')
print(g_p)
print(g_p.vertices_nao_adjacentes())
print(g_p.ha_laco())
print(g_p.ha_paralelas())
print(g_p.grau("C"))
print(g_p.arestas_sobre_vertice("C"))
for x in g_p.N:
print(g_p.grau(x))
class TestGrafo(unittest.TestCase):
def setUp(self):
# Grafo da Paraíba
self.g_p = Grafo(['J', 'C', 'E', 'P', 'M', 'T', 'Z'])
# {'a1':'J-C', 'a2':'C-E', 'a3':'C-E', 'a4':'C-P', 'a5':'C-P', 'a6':'C-M', 'a7':'C-T', 'a8':'M-T', 'a9':'T-Z'}
self.g_p.adicionaAresta('J-C')
self.g_p.adicionaAresta('C-E')
self.g_p.adicionaAresta('C-E')
self.g_p.adicionaAresta('C-P')
self.g_p.adicionaAresta('C-P')
self.g_p.adicionaAresta('C-M')
self.g_p.adicionaAresta('C-T')
self.g_p.adicionaAresta('M-T')
self.g_p.adicionaAresta('T-Z')
# Grafo da Paraíba sem arestas paralelas
self.g_p_sem_paralelas = Grafo(['J', 'C', 'E', 'P', 'M', 'T', 'Z'])
self.g_p_sem_paralelas.adicionaAresta('J-C')
self.g_p_sem_paralelas.adicionaAresta('C-E')
self.g_p_sem_paralelas.adicionaAresta('C-P')
self.g_p_sem_paralelas.adicionaAresta('C-M')
self.g_p_sem_paralelas.adicionaAresta('C-T')
self.g_p_sem_paralelas.adicionaAresta('M-T')
self.g_p_sem_paralelas.adicionaAresta('T-Z')
# Grafos completos
# self.g_c = Grafo(['J', 'C', 'E', 'P'], {'a1':'J-C', 'a3':'J-E', 'a4':'J-P', 'a6':'C-E', 'a7':'C-P', 'a8':'E-P'})
self.g_c = Grafo(['J', 'C', 'E', 'P'])
self.g_c.adicionaAresta('J-C')
self.g_c.adicionaAresta('J-E')
self.g_c.adicionaAresta('J-P')
self.g_c.adicionaAresta('C-E')
self.g_c.adicionaAresta('C-P')
self.g_c.adicionaAresta('E-P')
self.g_c3 = Grafo(['J'])
# Grafos com laco
# self.g_l1 = Grafo(['A', 'B', 'C', 'D'], {'a1':'A-A', 'a2':'B-A', 'a3':'A-A'})
self.g_l1 = Grafo(['A', 'B', 'C', 'D'])
self.g_l1.adicionaAresta('A-A')
self.g_l1.adicionaAresta('A-A')
self.g_l1.adicionaAresta('B-A')
# self.g_l2 = Grafo(['A', 'B', 'C', 'D'], {'a1':'A-B', 'a2':'B-B', 'a3':'B-A'})
self.g_l2 = Grafo(['A', 'B', 'C', 'D'])
self.g_l2.adicionaAresta('A-B')
self.g_l2.adicionaAresta('B-B')
self.g_l2.adicionaAresta('B-A')
# self.g_l3 = Grafo(['A', 'B', 'C', 'D'], {'a1':'C-A', 'a2':'C-C', 'a3':'D-D'})
self.g_l3 = Grafo(['A', 'B', 'C', 'D'])
self.g_l3.adicionaAresta('C-A')
self.g_l3.adicionaAresta('C-C')
self.g_l3.adicionaAresta('D-D')
# self.g_l4 = Grafo(['D'], {'a2':'D-D'})
self.g_l4 = Grafo(['D'])
self.g_l4.adicionaAresta('D-D')
# self.g_l5 = Grafo(['C', 'D'], {'a2':'D-C', 'a3':'C-C'})
self.g_l5 = Grafo(['C', 'D'])
self.g_l5.adicionaAresta('D-C')
self.g_l5.adicionaAresta('C-C')
# Grafos criados por nós
self.g_1 = Grafo(['A', 'B', 'C', 'D', 'E', 'F', 'G'])
self.g_1.adicionaAresta('A-B')
self.g_1.adicionaAresta('B-C')
self.g_1.adicionaAresta('C-D')
self.g_1.adicionaAresta('D-E')
self.g_1.adicionaAresta('E-F')
self.g_1.adicionaAresta('F-G')
self.g_1.adicionaAresta('G-E')
self.g_1.adicionaAresta('E-C')
self.g_1.adicionaAresta('C-A')
self.g_2 = Grafo(['1', '2', '3', '4', '5', '6', '7', '8', '9'])
self.g_2.adicionaAresta('1-2')
self.g_2.adicionaAresta('1-5')
self.g_2.adicionaAresta('1-4')
self.g_2.adicionaAresta('4-5')
self.g_2.adicionaAresta('5-2')
self.g_2.adicionaAresta('2-3')
self.g_2.adicionaAresta('3-9')
self.g_2.adicionaAresta('6-8')
self.g_2.adicionaAresta('8-7')
self.g_2.adicionaAresta('7-6')
self.g_3 = Grafo(['A', 'B', 'C', 'D', 'E', 'F'])
self.g_3.adicionaAresta('A-B')
self.g_3.adicionaAresta('A-C')
self.g_3.adicionaAresta('B-D')
self.g_3.adicionaAresta('B-E')
self.g_3.adicionaAresta('C-E')
self.g_3.adicionaAresta('C-F')
self.g_3.adicionaAresta('D-E')
self.g_3.adicionaAresta('E-F')
self.g_3.adicionaAresta('B-C')
self.g_4 = Grafo(['A', 'B', 'C', 'D', 'E', 'F'])
self.g_4.adicionaAresta('A-D')
self.g_4.adicionaAresta('A-B')
self.g_4.adicionaAresta('C-A')
self.g_4.adicionaAresta('C-F')
self.g_4.adicionaAresta('C-D')
self.g_4.adicionaAresta('D-F')
self.g_4.adicionaAresta('B-D')
self.g_4.adicionaAresta('E-A')
self.g_4.adicionaAresta('E-C')
self.g_5 = Grafo(['A', 'B', 'C', 'D', 'E'])
self.g_5.adicionaAresta('A-B')
self.g_5.adicionaAresta('A-C')
self.g_5.adicionaAresta('A-D')
self.g_5.adicionaAresta('C-D')
self.g_5.adicionaAresta('B-D')
self.g_5.adicionaAresta('B-E')
self.g_5.adicionaAresta('D-E')
self.g_7 = Grafo(['A', 'B', 'C', 'D', 'E'])
self.g_7.adicionaAresta('A-B')
self.g_7.adicionaAresta('A-C')
self.g_7.adicionaAresta('A-D')
self.g_7.adicionaAresta('B-D')
self.g_7.adicionaAresta('D-C')
self.g_7.adicionaAresta('B-E')
self.g_7.adicionaAresta('C-E')
def test_vertices_nao_adjacentes(self):
self.assertEqual(self.g_p.vertices_nao_adjacentes(), [
'J-J', 'J-E', 'J-P', 'J-M', 'J-T', 'J-Z', 'C-C', 'C-Z', 'E-E',
'E-P', 'E-M', 'E-T', 'E-Z', 'P-P', 'P-M', 'P-T', 'P-Z', 'M-M',
'M-Z', 'T-T', 'Z-Z'
])
self.assertEqual(self.g_c.vertices_nao_adjacentes(),
['J-J', 'C-C', 'E-E', 'P-P'])
self.assertEqual(self.g_c3.vertices_nao_adjacentes(), ['J-J'])
def test_ha_laco(self):
self.assertFalse(self.g_p.ha_laco())
self.assertFalse(self.g_p_sem_paralelas.ha_laco())
self.assertTrue(self.g_l1.ha_laco())
self.assertTrue(self.g_l2.ha_laco())
self.assertTrue(self.g_l3.ha_laco())
self.assertTrue(self.g_l4.ha_laco())
self.assertTrue(self.g_l5.ha_laco())
def test_grau(self):
# Paraíba
self.assertEqual(self.g_p.grau('J'), 1)
self.assertEqual(self.g_p.grau('C'), 7)
self.assertEqual(self.g_p.grau('E'), 2)
self.assertEqual(self.g_p.grau('P'), 2)
self.assertEqual(self.g_p.grau('M'), 2)
self.assertEqual(self.g_p.grau('T'), 3)
self.assertEqual(self.g_p.grau('Z'), 1)
# Completos
self.assertEqual(self.g_c.grau('J'), 3)
self.assertEqual(self.g_c.grau('C'), 3)
self.assertEqual(self.g_c.grau('E'), 3)
self.assertEqual(self.g_c.grau('P'), 3)
# Com laço. Lembrando que cada laço conta uma única vez por vértice para cálculo do grau
self.assertEqual(self.g_l1.grau('A'), 3)
self.assertEqual(self.g_l2.grau('B'), 3)
self.assertEqual(self.g_l4.grau('D'), 1)
def test_arestas_ha_paralelas(self):
self.assertTrue(self.g_p.ha_paralelas())
self.assertFalse(self.g_p_sem_paralelas.ha_paralelas())
self.assertFalse(self.g_c.ha_paralelas())
self.assertFalse(self.g_c3.ha_paralelas())
self.assertTrue(self.g_l1.ha_paralelas())
def test_arestas_sobre_vertice(self):
# {'a1': 'J-C', 'a2': 'C-E', 'a3': 'C-E', 'a4': 'C-P', 'a5': 'C-P', 'a6': 'C-M', 'a7': 'C-T', 'a8': 'M-T',
# 'a9': 'T-Z'}
self.assertEqual(set(self.g_p.arestas_sobre_vertice('J')),
set(['J-C']))
self.assertEqual(
set(self.g_p.arestas_sobre_vertice('C')),
set(['J-C', 'C-E', 'C-E', 'C-P', 'C-P', 'C-M', 'C-T']))
self.assertEqual(set(self.g_p.arestas_sobre_vertice('M')),
set(['C-M', 'M-T']))
def test_eh_completo(self):
self.assertFalse(self.g_p.eh_completo())
self.assertFalse((self.g_p_sem_paralelas.eh_completo()))
self.assertTrue((self.g_c.eh_completo()))
# self.assertTrue((self.g_c2.eh_completo())) não existe referência.
self.assertTrue((self.g_c3.eh_completo()))
self.assertFalse((self.g_l1.eh_completo()))
self.assertFalse((self.g_l2.eh_completo()))
self.assertFalse((self.g_l3.eh_completo()))
self.assertTrue((self.g_l4.eh_completo()))
self.assertTrue((self.g_l5.eh_completo()))
def test_caminhoEuleriano(self):
self.assertFalse(self.g_p.caminhoEuleriano())
self.assertTrue(self.g_1.caminhoEuleriano())
self.assertFalse(self.g_2.caminhoEuleriano())
self.assertTrue(self.g_3.caminhoEuleriano())
self.assertTrue(self.g_4.caminhoEuleriano())
self.assertTrue(self.g_5.caminhoEuleriano())
self.assertFalse(self.g_p_sem_paralelas.caminhoEuleriano())
self.assertFalse(self.g_c.caminhoEuleriano())
self.assertTrue(self.g_l1.caminhoEuleriano())
self.assertFalse(self.g_l2.caminhoEuleriano())
self.assertTrue(self.g_l3.caminhoEuleriano())
def test_fleury(self):
self.assertEqual(self.g_1.fleury(),
['A', 'B', 'C', 'D', 'E', 'F', 'G', 'E', 'C', 'A'])
self.assertFalse(self.g_2.fleury())
self.assertEqual(self.g_3.fleury(),
['A', 'B', 'C', 'E', 'D', 'B', 'E', 'F', 'C', 'A'])
self.assertEqual(self.g_4.fleury(),
['B', 'A', 'C', 'D', 'F', 'C', 'E', 'A', 'D', 'B'])
self.assertEqual(self.g_5.fleury(),
['A', 'B', 'D', 'C', 'A', 'D', 'E', 'B'])
self.assertFalse(self.g_p.fleury())
self.assertFalse(self.g_p_sem_paralelas.fleury())
self.assertFalse(self.g_c.fleury())
self.assertEqual(self.g_l1.fleury(), ['A', 'B'])
self.assertFalse(self.g_l2.fleury())
self.assertEqual(self.g_l3.fleury(), ['A'])
def test_ciclo_hamiltoniano(self):
self.assertFalse(self.g_1.ciclo_hamiltoniano())
self.assertFalse(self.g_2.ciclo_hamiltoniano())
self.assertEqual(self.g_3.ciclo_hamiltoniano(),
['A', 'B', 'D', 'E', 'F', 'C', 'A'])
self.assertEqual(self.g_4.ciclo_hamiltoniano(),
['A', 'B', 'D', 'F', 'C', 'E', 'A'])
self.assertEqual(self.g_5.ciclo_hamiltoniano(),
['A', 'B', 'E', 'D', 'C', 'A'])
self.assertEqual(self.g_7.ciclo_hamiltoniano(),
['A', 'B', 'E', 'C', 'D', 'A'])
self.assertEqual(self.g_c.ciclo_hamiltoniano(),
['J', 'C', 'E', 'P', 'J'])
self.assertFalse(self.g_l1.ciclo_hamiltoniano())
self.assertFalse(self.g_l2.ciclo_hamiltoniano())
self.assertFalse(self.g_l3.ciclo_hamiltoniano())
class TestGrafo(unittest.TestCase):
def setUp(self):
# Grafo da Paraíba
self.g_p = Grafo(['J', 'C', 'E', 'P', 'M', 'T', 'Z'])
#{'a1':'J-C', 'a2':'C-E', 'a3':'C-E', 'a4':'C-P', 'a5':'C-P', 'a6':'C-M', 'a7':'C-T', 'a8':'M-T', 'a9':'T-Z'}
self.g_p.adicionaAresta('J-C', 3)
self.g_p.adicionaAresta('C-E', 3)
self.g_p.adicionaAresta('C-E', 2)
self.g_p.adicionaAresta('C-P', 1)
self.g_p.adicionaAresta('C-P', 7)
self.g_p.adicionaAresta('C-M', 5)
self.g_p.adicionaAresta('C-T', 4)
self.g_p.adicionaAresta('M-T', 3)
self.g_p.adicionaAresta('T-Z', 4)
# Grafo da Paraíba sem arestas paralelas
self.g_p_sem_paralelas = Grafo(['J', 'C', 'E', 'P', 'M', 'T', 'Z'])
self.g_p_sem_paralelas.adicionaAresta('J-C', 3)
self.g_p_sem_paralelas.adicionaAresta('C-E', 6)
self.g_p_sem_paralelas.adicionaAresta('C-P', 7)
self.g_p_sem_paralelas.adicionaAresta('C-M', 4)
self.g_p_sem_paralelas.adicionaAresta('C-T', 4)
self.g_p_sem_paralelas.adicionaAresta('M-T',8)
self.g_p_sem_paralelas.adicionaAresta('T-Z', 9)
# Grafos completos
#self.g_c = Grafo(['J', 'C', 'E', 'P'], {'a1':'J-C', 'a3':'J-E', 'a4':'J-P', 'a6':'C-E', 'a7':'C-P', 'a8':'E-P'})
self.g_c = Grafo(['J', 'C', 'E', 'P'])
self.g_c.adicionaAresta('J-C', 4)
self.g_c.adicionaAresta('J-E', 2)
self.g_c.adicionaAresta('J-P', 1)
self.g_c.adicionaAresta('C-E', 5)
self.g_c.adicionaAresta('C-P', 8)
self.g_c.adicionaAresta('E-P', 3)
g = Grafo([], {})
for i in ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']:
g.adicionaVertice(i)
g.adicionaAresta("a-g", 4)
g.adicionaAresta("a-b", 9)
g.adicionaAresta("b-c", 6)
g.adicionaAresta("b-h", 7)
g.adicionaAresta("b-g", 10)
g.adicionaAresta("c-d", 8)
g.adicionaAresta("c-f", 8)
g.adicionaAresta("d-e", 14)
g.adicionaAresta("c-e", 12)
g.adicionaAresta("e-f", 2)
g.adicionaAresta("f-h", 2)
g.adicionaAresta("f-g", 1)
g2 = Grafo([], {})
g2.adicionaVertice('a')
g2.adicionaVertice('b')
g2.adicionaVertice('c')
g2.adicionaVertice('d')
g2.adicionaVertice('e')
g2.adicionaVertice('f')
g2.adicionaAresta("a-b", 9)
g2.adicionaAresta("b-c", 6)
g2.adicionaAresta("c-d", 8)
g2.adicionaAresta("c-f", 8)
g2.adicionaAresta("d-e", 14)
g2.adicionaAresta("c-e", 12)
g2.adicionaAresta("e-f", 2)
g3 = Grafo([], {})
for i in ['a', 'b', 'c', 'd', 'e', 'f', 'g']:
g3.adicionaVertice(i)
g3.adicionaAresta("a-g", 5)
g3.adicionaAresta("a-b", 19)
g3.adicionaAresta("b-c", 16)
g3.adicionaAresta("b-g", 13)
g3.adicionaAresta("c-d", 19)
g3.adicionaAresta("c-f", 1)
g3.adicionaAresta("d-e", 21)
g3.adicionaAresta("c-e", 30)
g3.adicionaAresta("e-f", 15)
g3.adicionaAresta("f-g", 3)
g4 = Grafo([], {})
for i in ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm']:
g4.adicionaVertice(i)
g4.adicionaAresta("a-g", 5)
g4.adicionaAresta("a-b", 19)
g4.adicionaAresta("b-c", 16)
g4.adicionaAresta("b-g", 13)
g4.adicionaAresta("c-d", 19)
g4.adicionaAresta("c-f", 1)
g4.adicionaAresta("d-e", 21)
g4.adicionaAresta("c-e", 30)
g4.adicionaAresta("e-f", 15)
g4.adicionaAresta("f-g", 3)
g4.adicionaAresta("g-m", 5)
g4.adicionaAresta("i-k", 1)
g4.adicionaAresta("a-m", 14)
g4.adicionaAresta("j-l", 9)
g4.adicionaAresta("i-m", 8)
g4.adicionaAresta("f-i", 11)
g4.adicionaAresta("f-h", 10)
g4.adicionaAresta("c-e", 13)
g4.adicionaAresta("e-j", 20)
g4.adicionaAresta("f-k", 19)
g5 = Grafo([], {})
for i in ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']:
g5.adicionaVertice(i)
g5.adicionaAresta("a-g", 4)
g5.adicionaAresta("a-b", 9)
g5.adicionaAresta("b-c", 6)
g5.adicionaAresta("b-h", 7)
g5.adicionaAresta("b-g", 10)
g5.adicionaAresta("c-d", 8)
g5.adicionaAresta("c-f", 8)
g5.adicionaAresta("d-e", 14)
g5.adicionaAresta("c-e", 12)
g5.adicionaAresta("e-f", 2)
g5.adicionaAresta("f-h", 2)
g5.adicionaAresta("f-g", 1)
g6 = Grafo([], {})
g6.adicionaVertice('a')
g6.adicionaVertice('b')
g6.adicionaVertice('c')
g6.adicionaVertice('d')
g6.adicionaVertice('e')
g6.adicionaVertice('f')
g6.adicionaAresta("a-b", 9)
g6.adicionaAresta("b-c", 6)
g6.adicionaAresta("c-d", 8)
g6.adicionaAresta("c-f", 8)
g6.adicionaAresta("d-e", 14)
g6.adicionaAresta("c-e", 12)
g6.adicionaAresta("e-f", 2)
g7 = Grafo([], {})
for i in ['a', 'b', 'c', 'd', 'e', 'f', 'g']:
g7.adicionaVertice(i)
g7.adicionaAresta("a-c", 50)
g7.adicionaAresta("a-d", 49)
g7.adicionaAresta("b-f", 55)
g7.adicionaAresta("b-g", 60)
g7.adicionaAresta("c-d", 45)
g7.adicionaAresta("c-g", 52)
g7.adicionaAresta("d-f", 44)
g7.adicionaAresta("c-g", 56)
g7.adicionaAresta("e-f", 10)
g8 = Grafo([], {})
for i in ['a', 'b', 'c', 'd', 'e', 'f', 'g']:
g8.adicionaVertice(i)
g8.adicionaAresta("a-b", 5)
g8.adicionaAresta("a-e", 12)
g8.adicionaAresta("b-g", 4)
g8.adicionaAresta("b-f", 9)
g8.adicionaAresta("c-d", 10)
g8.adicionaAresta("c-f", 7)
g8.adicionaAresta("d-f", 8)
g8.adicionaAresta("c-e", 10)
g8.adicionaAresta("e-g", 2)
g8.adicionaAresta("f-g", 6)
def test_vertices_nao_adjacentes(self):
self.assertEqual(self.g_p.vertices_nao_adjacentes(), ['J-J', 'J-E', 'J-P', 'J-M', 'J-T', 'J-Z', 'C-C', 'C-Z', 'E-E', 'E-P', 'E-M', 'E-T', 'E-Z', 'P-P', 'P-M', 'P-T', 'P-Z', 'M-M', 'M-Z', 'T-T', 'Z-Z'])
self.assertEqual(self.g_c.vertices_nao_adjacentes(), ['J-J', 'C-C', 'E-E', 'P-P'])
self.assertEqual(self.g_c3.vertices_nao_adjacentes(), ['J-J'])
def test_ha_laco(self):
self.assertFalse(self.g_p.ha_laco())
self.assertFalse(self.g_p_sem_paralelas.ha_laco())
self.assertTrue(self.g_l1.ha_laco())
self.assertTrue(self.g_l2.ha_laco())
self.assertTrue(self.g_l3.ha_laco())
self.assertTrue(self.g_l4.ha_laco())
self.assertTrue(self.g_l5.ha_laco())
def test_grau(self):
# Paraíba
self.assertEqual(self.g_p.grau('J'), 1)
self.assertEqual(self.g_p.grau('C'), 7)
self.assertEqual(self.g_p.grau('E'), 2)
self.assertEqual(self.g_p.grau('P'), 2)
self.assertEqual(self.g_p.grau('M'), 2)
self.assertEqual(self.g_p.grau('T'), 3)
self.assertEqual(self.g_p.grau('Z'), 1)
# Completos
self.assertEqual(self.g_c.grau('J'), 3)
self.assertEqual(self.g_c.grau('C'), 3)
self.assertEqual(self.g_c.grau('E'), 3)
self.assertEqual(self.g_c.grau('P'), 3)
# Com laço. Lembrando que cada laço conta uma única vez por vértice para cálculo do grau
self.assertEqual(self.g_l1.grau('A'), 3)
self.assertEqual(self.g_l2.grau('B'), 3)
self.assertEqual(self.g_l4.grau('D'), 1)
def test_arestas_ha_paralelas(self):
self.assertTrue(self.g_p.ha_paralelas())
self.assertFalse(self.g_p_sem_paralelas.ha_paralelas())
self.assertFalse(self.g_c.ha_paralelas())
self.assertFalse(self.g_c3.ha_paralelas())
self.assertTrue(self.g_l1.ha_paralelas())
def test_arestas_sobre_vertice(self):
#{'a1': 'J-C', 'a2': 'C-E', 'a3': 'C-E', 'a4': 'C-P', 'a5': 'C-P', 'a6': 'C-M', 'a7': 'C-T', 'a8': 'M-T',
# 'a9': 'T-Z'}
self.assertEqual(set(self.g_p.arestas_sobre_vertice('J')), set(['J-C']))
self.assertEqual(set(self.g_p.arestas_sobre_vertice('C')), set(['C-J', 'C-E', 'C-E', 'C-P', 'C-P', 'C-M', 'C-T']))
self.assertEqual(set(self.g_p.arestas_sobre_vertice('M')), set(['M-C', 'M-T']))
def test_eh_completo(self):
self.assertFalse(self.g_p.eh_completo())
self.assertFalse((self.g_p_sem_paralelas.eh_completo()))
self.assertTrue((self.g_c.eh_completo()))
self.assertTrue((self.g_c.eh_completo()))
self.assertTrue((self.g_c3.eh_completo()))
self.assertFalse((self.g_l1.eh_completo()))
self.assertFalse((self.g_l2.eh_completo()))
self.assertFalse((self.g_l3.eh_completo()))
self.assertTrue((self.g_l4.eh_completo()))
self.assertTrue((self.g_l5.eh_completo()))
def test_kruskal(self):
self.assertEqual(self.g_p_sem_paralelas.Kruskal(), ['J-C', 'C-M', 'M-T', 'T-Z'])
self.assertEqual(self.g3.Kruskal(), ['c-f', 'f-g', 'a-g', 'b-g', 'e-f', 'd-e'])
self.assertEqual(self.g4.Kruskal(), ['c-f', 'i-k', 'f-g', 'a-g', 'g-m', 'j-l', 'b-g', 'e-f', 'd-e'])
self.assertEqual(self.g5.Kruskal(), ['f-g', 'e-f', 'a-g', 'b-c', 'c-d', 'd-e'])
self.assertEqual(self.g6.Kruskal(), ['e-f', 'b-c', 'c-d', 'a-b', 'd-e'])
self.assertEqual(self.g7.Kruskal(), ['e-f', 'd-f', 'c-d', 'a-d', 'b-f'])
self.assertEqual(self.g8.Kruskal(), ['e-g', 'b-g', 'a-b', 'f-g', 'c-f', 'd-f'])