def main():
grafo = Grafo([], [])
for i in ['J', 'C', 'E', 'P', 'M', 'T', 'Z']:
grafo.adiciona_vertice(i)
for i in [('J-C', 3), ('C-E', 1), ('C-P', 5), ('C-M', 4), ('C-T', 2),
('M-T', 3), ('P-M', 1), ('T-Z', 6), ('M-Z', 9)]:
grafo.adiciona_aresta(*i)
print()
print(grafo)
print(kruskall(grafo, 9, 1, 4))
def main():
grafo = Grafo([], [])
for i in ['J', 'C', 'E', 'P', 'M', 'T', 'Z']:
grafo.adiciona_vertice(i)
for i in [('J-C', 3), ('C-E', 1), ('C-P', 5), ('C-M', 4), ('C-T', 2),
('M-T', 3), ('P-M', 1), ('T-Z', 6), ('M-Z', 9)]:
grafo.adiciona_aresta(*i)
print("\nOriginal\n")
print(grafo)
print()
print("Minimal Spanning Tree\n")
mst = Prim(grafo)
print(mst)
def criarMSTmodificado(g: Grafo, caixas):
chaves = list(caixas.keys())
chaves.sort()
mst = Grafo()
ok = False
for i in range(len(chaves)):
chave = chaves[i]
while len(caixas[chave]) != 0:
aresta = caixas[chave].pop()
peso = int(aresta[0])
aresta = aresta[1:]
v1 = aresta[0]
v2 = aresta[-1]
arvoresDiferentes = False
if not mst.existe_vertice(v1):
mst.adiciona_vertice(v1)
arvoresDiferentes = True
if not mst.existe_vertice(v2):
mst.adiciona_vertice(v2)
arvoresDiferentes = True
if not mst.existe_aresta(aresta):
if (arvoresDiferentes):
mst.adiciona_aresta(aresta, peso)
if (mst.quantidadeVertices == g.quantidadeVertices):
ok = True
break
if (ok):
break
return mst
class TestEuler(unittest.TestCase):
def setUp(self):
self.judA = Grafo([], []) # grafo com caminho euleriano, com vertices de grau ímpar no começo.
for i in ['T', 'B', 'M', 'R']:
self.judA.adiciona_vertice(i)
for i in ['M-T', 'M-T', 'M-B', 'M-B', 'M-R', 'M-R', 'B-R', 'T-R']:
self.judA.adiciona_aresta(i)
self.judB = Grafo([], []) # grafo com caminho euleriano, com vertices apenas de grau par.
for i in ['T', 'B', 'M', 'R']:
self.judB.adiciona_vertice(i)
for i in ['M-T', 'M-T', 'M-B', 'M-B', 'M-R', 'M-R']:
self.judB.adiciona_aresta(i)
self.grafo_3 = Grafo([], [])
for i in ['A', 'B', 'C', 'D']:
self.grafo_3.adiciona_vertice(i)
for i in ['A-B', 'A-C', 'B-D', 'D-D', 'C-C']:
self.grafo_3.adiciona_aresta(i)
# Pontes de Konigsberg
self.konigsberg = Grafo([], [])
for i in ['M', 'T', 'B', 'R']:
self.konigsberg.adiciona_vertice(i)
for i in ['M-T', 'M-T', 'M-B', 'M-B', 'M-R', 'B-R', 'T-R']:
self.konigsberg.adiciona_aresta(i)
# Grafos com caminho euleriano
self.konigsberg_mod = Grafo([], [])
for i in ['M', 'T', 'B', 'R']:
self.konigsberg_mod.adiciona_vertice(i)
for i in ['M-T', 'M-T', 'M-B', 'M-B', 'M-R', 'M-R', 'B-R', 'T-R']:
self.konigsberg_mod.adiciona_aresta(i)
self.g_c_e = Grafo([], [])
for i in ['A', 'B', 'C']:
self.g_c_e.adiciona_vertice(i)
for i in ['A-B', 'B-C']:
self.g_c_e.adiciona_aresta(i)
# Grafo da Paraíba
self.g_p = Grafo([], [])
for i in ['J', 'C', 'E', 'P', 'M', 'T', 'Z']:
self.g_p.adiciona_vertice(i)
for i in ['J-C', 'C-E', 'C-E', 'C-P', 'C-P', 'C-M', 'C-T', 'M-T', 'T-Z']:
self.g_p.adiciona_aresta(i)
# Grafo da Paraíba sem arestas paralelas
self.g_p_sem_paralelas = Grafo([], [])
for i in ['J', 'C', 'E', 'P', 'M', 'T', 'Z']:
self.g_p_sem_paralelas.adiciona_vertice(i)
for i in ['J-C', 'C-E', 'C-P', 'C-M', 'C-T', 'M-T', 'T-Z']:
self.g_p_sem_paralelas.adiciona_aresta(i)
# Grafos completos
self.g_c = Grafo([], [])
for i in ['J', 'C', 'E', 'P']:
self.g_c.adiciona_vertice(i)
for i in ['J-C', 'J-E', 'J-P', 'C-E', 'C-P', 'E-P']:
self.g_c.adiciona_aresta(i)
self.g_c2 = Grafo([], [])
for i in ['J', 'C', 'E', 'P']:
self.g_c2.adiciona_vertice(i)
for i in ['J-C', 'E-J', 'J-P', 'E-C', 'C-P', 'P-E']:
self.g_c2.adiciona_aresta(i)
self.g_c3 = Grafo([], [])
self.g_c3.adiciona_vertice('J')
# Grafos com laco
self.g_l1 = Grafo([], [])
for i in ['A', 'B', 'C', 'D']:
self.g_l1.adiciona_vertice(i)
for i in ['A-A', 'B-A', 'A-A']:
self.g_l1.adiciona_aresta(i)
self.g_l2 = Grafo([], [])
for i in ['A', 'B', 'C', 'D']:
self.g_l2.adiciona_vertice(i)
for i in ['A-B', 'B-B', 'B-A']:
self.g_l2.adiciona_aresta(i)
self.g_l3 = Grafo([], [])
for i in ['A', 'B', 'C', 'D']:
self.g_l3.adiciona_vertice(i)
for i in ['C-A', 'C-C', 'D-D']:
self.g_l3.adiciona_aresta(i)
self.g_l4 = Grafo([], [])
self.g_l4.adiciona_vertice('D')
self.g_l4.adiciona_aresta('D-D')
self.g_l5 = Grafo([], [])
for i in ['C', 'D']:
self.g_l5.adiciona_vertice(i)
for i in ['D-C', 'C-C']:
self.g_l5.adiciona_aresta(i)
def test_caminho_euleriano(self):
self.assertTrue(self.konigsberg_mod.caminho_euleriano())
self.assertTrue(self.g_c_e.caminho_euleriano())
self.assertTrue(self.grafo_3.caminho_euleriano())
self.assertTrue(self.judA.caminho_euleriano())
self.assertTrue(self.judB.caminho_euleriano())
self.assertFalse(self.konigsberg.caminho_euleriano())
self.assertFalse(self.g_p.caminho_euleriano())
self.assertFalse(self.g_p_sem_paralelas.caminho_euleriano())
self.assertFalse(self.g_c.caminho_euleriano())
def test_caminho_euleriano_path(self):
self.assertEqual(self.konigsberg_mod.caminho_euleriano_path(), ['T', 'a7', 'R', 'a5', 'M', 'a1', 'T', 'a2', 'M', 'a3', 'B', 'a8', 'R', 'a6', 'M', 'a4', 'B'])
self.assertEqual(self.g_c_e.caminho_euleriano_path(), ['A', 'a1', 'B', 'a2', 'C'])
self.assertEqual(self.grafo_3.caminho_euleriano_path(), ['C', 'a2', 'A', 'a1', 'B', 'a3', 'D'])
self.assertEqual(self.judA.caminho_euleriano_path(), ['T', 'a1', 'M', 'a7', 'R', 'a3', 'T', 'a2', 'M', 'a8', 'R', 'a6', 'B', 'a4', 'M', 'a5', 'B'])
self.assertEqual(self.judB.caminho_euleriano_path(), ['T', 'a1', 'M', 'a5', 'R', 'a6', 'M', 'a3', 'B', 'a4', 'M', 'a2', 'T'])
self.assertFalse(self.konigsberg.caminho_euleriano_path())
self.assertFalse(self.g_p.caminho_euleriano_path())
self.assertFalse(self.g_p_sem_paralelas.caminho_euleriano_path())
self.assertFalse(self.g_c.caminho_euleriano_path())
class TestEuler(unittest.TestCase):
def setUp(self):
# Pontes de Konigsberg
self.konigsberg = Grafo([], [])
for i in ['M', 'T', 'B', 'R']:
self.konigsberg.adiciona_vertice(i)
for i in ['M-T', 'M-T', 'M-B', 'M-B', 'M-R', 'B-R', 'T-R']:
self.konigsberg.adiciona_aresta(i)
# Grafos com caminho euleriano
self.konigsberg_mod = Grafo([], [])
for i in ['M', 'T', 'B', 'R']:
self.konigsberg_mod.adiciona_vertice(i)
for i in ['M-T', 'M-T', 'M-B', 'M-B', 'M-R', 'M-R', 'B-R', 'T-R']:
self.konigsberg_mod.adiciona_aresta(i)
self.g_c_e = Grafo([], [])
for i in ['A', 'B', 'C']:
self.g_c_e.adiciona_vertice(i)
for i in ['A-B', 'B-C']:
self.g_c_e.adiciona_aresta(i)
# Grafo da Paraíba
self.g_p = Grafo([], [])
for i in ['J', 'C', 'E', 'P', 'M', 'T', 'Z']:
self.g_p.adiciona_vertice(i)
for i in [
'J-C', 'C-E', 'C-E', 'C-P', 'C-P', 'C-M', 'C-T', 'M-T', 'T-Z'
]:
self.g_p.adiciona_aresta(i)
# Grafo da Paraíba sem arestas paralelas
self.g_p_sem_paralelas = Grafo([], [])
for i in ['J', 'C', 'E', 'P', 'M', 'T', 'Z']:
self.g_p_sem_paralelas.adiciona_vertice(i)
for i in ['J-C', 'C-E', 'C-P', 'C-M', 'C-T', 'M-T', 'T-Z']:
self.g_p_sem_paralelas.adiciona_aresta(i)
# Grafos completos
self.g_c = Grafo([], [])
for i in ['J', 'C', 'E', 'P']:
self.g_c.adiciona_vertice(i)
for i in ['J-C', 'J-E', 'J-P', 'C-E', 'C-P', 'E-P']:
self.g_c.adiciona_aresta(i)
self.g_c2 = Grafo([], [])
for i in ['J', 'C', 'E', 'P']:
self.g_c2.adiciona_vertice(i)
for i in ['J-C', 'E-J', 'J-P', 'E-C', 'C-P', 'P-E']:
self.g_c2.adiciona_aresta(i)
self.g_c3 = Grafo([], [])
self.g_c3.adiciona_vertice('J')
# Grafos com laco
self.g_l1 = Grafo([], [])
for i in ['A', 'B', 'C', 'D']:
self.g_l1.adiciona_vertice(i)
for i in ['A-A', 'B-A', 'A-A']:
self.g_l1.adiciona_aresta(i)
self.g_l2 = Grafo([], [])
for i in ['A', 'B', 'C', 'D']:
self.g_l2.adiciona_vertice(i)
for i in ['A-B', 'B-B', 'B-A']:
self.g_l2.adiciona_aresta(i)
self.g_l3 = Grafo([], [])
for i in ['A', 'B', 'C', 'D']:
self.g_l3.adiciona_vertice(i)
for i in ['C-A', 'C-C', 'D-D']:
self.g_l3.adiciona_aresta(i)
self.g_l4 = Grafo([], [])
self.g_l4.adiciona_vertice('D')
self.g_l4.adiciona_aresta('D-D')
self.g_l5 = Grafo([], [])
for i in ['C', 'D']:
self.g_l5.adiciona_vertice(i)
for i in ['D-C', 'C-C']:
self.g_l5.adiciona_aresta(i)
def test_caminho_euleriano(self):
self.assertTrue(caminho_euleriano(self.konigsberg_mod))
self.assertTrue(caminho_euleriano(self.g_c_e))
self.assertTrue(caminho_euleriano(self.g_c_e))
self.assertFalse(caminho_euleriano(self.konigsberg))
self.assertFalse(caminho_euleriano(self.g_p))
self.assertFalse(caminho_euleriano(self.g_p_sem_paralelas))
self.assertFalse(caminho_euleriano(self.g_c))
from grafo_adj_nao_dir import Grafo
g = Grafo([], [])
for i in ['a','b','c','d','e','f','g']:
g.adiciona_vertice(i)
for i in ['a-e','a-f','a-f','a-g','b-e','b-d','b-d','b-f','d-e','e-g']:
g.adiciona_aresta(i)
print(g.caminho_euleriano())
from grafo_adj_nao_dir import Grafo
g = Grafo([], [])
for i in ['M', 'T', 'B', 'R']:
g.adiciona_vertice(i)
for i in ['M-T', 'M-T', 'M-B', 'M-B', 'M-R', 'M-R', 'B-R', 'T-R']:
g.adiciona_aresta(i)
#print(g)
#print("M-T, T-R, R-M, M-B, B-R, R-M, M-B")
#print("\n")
g_c_e = Grafo([], [])
for i in ['A', 'B', 'C']:
g_c_e.adiciona_vertice(i)
for i in ['A-B', 'B-C']:
g_c_e.adiciona_aresta(i)
y = g.caminho()
print(y)
# g_l5 = Grafo([], [])
# for i in ['C', 'D']:
# g_l5.adiciona_vertice(i)
# for i in ['D-C', 'C-C']:
# g_l5.adiciona_aresta(i)
#
# print("g_l5")
# print(g_l5)
# print(g_l5.caminho_euleriano_path())
# grafos de judenilson
judA = Grafo(
[],
[]) # grafo com caminho euleriano, com vertices de grau ímpar no começo.
for i in ['T', 'B', 'M', 'R']:
judA.adiciona_vertice(i)
for i in ['M-T', 'M-T', 'M-B', 'M-B', 'M-R', 'M-R', 'B-R', 'T-R']:
judA.adiciona_aresta(i)
print("judA")
print(judA)
print(judA.caminho_euleriano_path())
# print(judA.caminho_euleriano())
# print(judA.new_eh_conexo())
judB = Grafo(
[], []) # grafo com caminho euleriano, com vertices apenas de grau par.
for i in ['T', 'B', 'M', 'R']:
judB.adiciona_vertice(i)
def Prim(g: Grafo):
if (g.quantidadeVertices == 0):
return None
mst = Grafo()
raiz = ModificacaoPrim(g) # Modificação
raiz = random.randint(
0, (g.quantidadeVertices - 1)) # Vertice Aleatório (Desativar linha)
print("Vertice Inicial: " + g.N[raiz] + "\n")
mst.adiciona_vertice(g.N[raiz])
ligacoesValidas = [0] * g.quantidadeVertices
for i in range(g.quantidadeVertices):
ligacoesValidas[i] = graphLibrary.grau(g, g.N[i])
arestasDaFilaPrincipal = {}
FilaPrincipal = PriorityQueue()
aux = 0
while (mst.quantidadeVertices != g.quantidadeVertices):
for k in range(aux, len(mst.N)):
Vertex = mst.N[k]
idx = g.N.index(Vertex)
if (ligacoesValidas[idx] == 0):
continue
for i in range(idx, len(g.M[idx])):
if (g.M[idx][i] > 0): # encontrei um vertice fora da arvore
v = g.N[i] # Possivel novo vertice
if not (mst.existe_vertice(v)):
pesoArestaEncontrada = g.Mfila[idx][i].seeFist()
arestaEncontrada = g.N[idx] + '-' + g.N[i]
if pesoArestaEncontrada in arestasDaFilaPrincipal.keys(
):
arestasDaFilaPrincipal[
pesoArestaEncontrada].append(arestaEncontrada)
else:
arestasDaFilaPrincipal[pesoArestaEncontrada] = [
arestaEncontrada
]
FilaPrincipal.insert(pesoArestaEncontrada)
idxfixo = idx
while ((idx - 1) >= 0):
if (g.M[idx - 1][idxfixo] > 0):
v = g.N[idx - 1] # Possivel novo vertice
if not (mst.existe_vertice(v)):
pesoArestaEncontrada = g.Mfila[idx -
1][idxfixo].seeFist()
arestaEncontrada = g.N[idx - 1] + '-' + g.N[idxfixo]
if pesoArestaEncontrada in arestasDaFilaPrincipal.keys(
):
arestasDaFilaPrincipal[
pesoArestaEncontrada].append(arestaEncontrada)
else:
arestasDaFilaPrincipal[pesoArestaEncontrada] = [
arestaEncontrada
]
FilaPrincipal.insert(pesoArestaEncontrada)
idx -= 1
menorPesoAresta = FilaPrincipal.remove()
novaAresta = arestasDaFilaPrincipal[menorPesoAresta].pop()
v1 = novaAresta[0]
v2 = novaAresta[-1]
novoVertice = None
if not mst.existe_vertice(v1):
novoVertice = v1
aux += 1
if not mst.existe_vertice(v2):
novoVertice = v2
aux += 1
if (novoVertice != None):
mst.adiciona_vertice(novoVertice)
mst.adiciona_aresta(novaAresta, menorPesoAresta)
idxV1 = g.N.index(v1)
idxV2 = g.N.index(v2)
ligacoesValidas[idxV1] -= 1
ligacoesValidas[idxV2] -= 1
return mst
class TestEuler(unittest.TestCase):
def setUp(self):
# Pontes de Konigsberg
self.konigsberg = Grafo([], [])
for i in ['M', 'T', 'B', 'R']:
self.konigsberg.adiciona_vertice(i)
for i in ['M-T', 'M-T', 'M-B', 'M-B', 'M-R', 'B-R', 'T-R']:
self.konigsberg.adiciona_aresta(i)
# Grafos com caminho euleriano
self.konigsberg_mod = Grafo([], [])
for i in ['M', 'T', 'B', 'R']:
self.konigsberg_mod.adiciona_vertice(i)
for i in ['M-T', 'M-T', 'M-B', 'M-B', 'M-R', 'M-R', 'B-R', 'T-R']:
self.konigsberg_mod.adiciona_aresta(i)
self.g_c_e = Grafo([], [])
for i in ['A', 'B', 'C']:
self.g_c_e.adiciona_vertice(i)
for i in ['A-B', 'B-C']:
self.g_c_e.adiciona_aresta(i)
# Grafo da Paraíba
self.g_p = Grafo([], [])
for i in ['J', 'C', 'E', 'P', 'M', 'T', 'Z']:
self.g_p.adiciona_vertice(i)
for i in [
'J-C', 'C-E', 'C-E', 'C-P', 'C-P', 'C-M', 'C-T', 'M-T', 'T-Z'
]:
self.g_p.adiciona_aresta(i)
# Grafo da Paraíba sem arestas paralelas
self.g_p_sem_paralelas = Grafo([], [])
for i in ['J', 'C', 'E', 'P', 'M', 'T', 'Z']:
self.g_p_sem_paralelas.adiciona_vertice(i)
for i in ['J-C', 'C-E', 'C-P', 'C-M', 'C-T', 'M-T', 'T-Z']:
self.g_p_sem_paralelas.adiciona_aresta(i)
# Grafos completos
self.g_c = Grafo([], [])
for i in ['J', 'C', 'E', 'P']:
self.g_c.adiciona_vertice(i)
for i in ['J-C', 'J-E', 'J-P', 'C-E', 'C-P', 'E-P']:
self.g_c.adiciona_aresta(i)
self.g_c2 = Grafo([], [])
for i in ['J', 'C', 'E', 'P']:
self.g_c2.adiciona_vertice(i)
for i in ['J-C', 'E-J', 'J-P', 'E-C', 'C-P', 'P-E']:
self.g_c2.adiciona_aresta(i)
self.g_c3 = Grafo([], [])
self.g_c3.adiciona_vertice('J')
# Grafos com laco
self.g_l1 = Grafo([], [])
for i in ['A', 'B', 'C', 'D']:
self.g_l1.adiciona_vertice(i)
for i in ['A-A', 'B-A', 'A-A']:
self.g_l1.adiciona_aresta(i)
self.g_l2 = Grafo([], [])
for i in ['A', 'B', 'C', 'D']:
self.g_l2.adiciona_vertice(i)
for i in ['A-B', 'B-B', 'A-B']:
self.g_l2.adiciona_aresta(i)
self.g_l3 = Grafo([], [])
for i in ['A', 'B', 'C', 'D']:
self.g_l3.adiciona_vertice(i)
for i in ['A-C', 'C-C', 'D-D']:
self.g_l3.adiciona_aresta(i)
self.g_l4 = Grafo([], [])
self.g_l4.adiciona_vertice('D')
self.g_l4.adiciona_aresta('D-D')
self.g_l5 = Grafo([], [])
for i in ['C', 'D']:
self.g_l5.adiciona_vertice(i)
for i in ['C-D', 'C-C']:
self.g_l5.adiciona_aresta(i)
self.g_16 = Grafo([], [])
for i in ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']:
self.g_16.adiciona_vertice(i)
for i in [
'a-c', 'a-c', 'a-e', 'a-f', 'a-g', 'a-h', 'b-d', 'b-g', 'c-h',
'c-h', 'd-e', 'd-f', 'e-f', 'f-g', 'g-h'
]:
self.g_16.adiciona_aresta(i)
self.g_17 = Grafo([], [])
for i in ['a', 'b', 'c', 'd', 'e', 'f', 'g']:
self.g_17.adiciona_vertice(i)
for i in [
'a-b', 'a-c', 'a-f', 'a-g', 'b-c', 'b-f', 'b-g', 'c-d', 'c-e',
'c-f', 'c-g', 'd-e', 'f-g'
]:
self.g_17.adiciona_aresta(i)
self.g_18 = Grafo([], [])
for i in ['a', 'b', 'c', 'd', 'e']:
self.g_18.adiciona_vertice(i)
for i in ['a-b', 'a-d', 'b-c', 'b-e', 'c-d']:
self.g_18.adiciona_aresta(i)
self.g_19 = Grafo([], [])
for i in ['C', 'D']:
self.g_19.adiciona_vertice(i)
for i in ['C-C', 'C-D']:
self.g_19.adiciona_aresta(i)
self.g_20 = Grafo([], [])
for i in ['a', 'b', 'c', 'd', 'e', 'f', 'g']:
self.g_20.adiciona_vertice(i)
for i in [
'a-e', 'a-f', 'a-f', 'a-g', 'b-e', 'b-d', 'b-d', 'b-f', 'd-e',
'e-g'
]:
self.g_20.adiciona_aresta(i)
def test_caminho_euleriano(self):
self.assertTrue(self.konigsberg_mod.caminho_euleriano())
self.assertTrue(self.g_c_e.caminho_euleriano())
self.assertFalse(self.konigsberg.caminho_euleriano())
self.assertFalse(self.g_p.caminho_euleriano())
self.assertFalse(self.g_p_sem_paralelas.caminho_euleriano())
self.assertFalse(self.g_c.caminho_euleriano())
self.assertEqual(self.g_16.caminho_euleriano(), [
'd', 'e', 'f', 'g', 'h', 'a', 'c', 'h', 'c', 'a', 'f', 'd', 'b',
'g', 'a', 'e'
])
self.assertEqual(self.g_17.caminho_euleriano(), [
'a', 'b', 'c', 'd', 'e', 'c', 'f', 'g', 'a', 'c', 'g', 'b', 'f',
'a'
])
self.assertEqual(self.g_18.caminho_euleriano(),
['b', 'c', 'd', 'a', 'b', 'e'])
self.assertEqual(self.g_19.caminho_euleriano(), ['C', 'D'])
self.assertEqual(
self.g_20.caminho_euleriano(),
['d', 'e', 'g', 'a', 'e', 'b', 'd', 'b', 'f', 'a', 'f'])
