예제 #1
0
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())
예제 #2
0
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'])
예제 #3
0
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()))
예제 #4
0
# 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))
예제 #5
0
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())
예제 #6
0
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'])