def __constroiGrafo(self):
# construindo o grafo Matriz de Incidencia (MxN)
self.grafo = [[0 for i in range(self.qtdVertices + 1)]
for i in range(self.qtdArestas)]
for i in range(2, len(self.linhasAqr) - 1):
linha = i - 2
# print(self.linhasAqr[i])
a, b = map(int, self.linhasAqr[i].split("--"))
self.grafo[linha][a] = 1
self.grafo[linha][b] = 1
cor = None
self.grafo[linha][self.qtdVertices] = cor
self.listAresta.append(Aresta(a, b, cor))
vA = Vertice(a)
vB = Vertice(b)
if a not in self.verticesChaves:
self.listVertice[a] = vA
self.verticesChaves.append(a)
if b not in self.verticesChaves:
self.listVertice[b] = vB
self.verticesChaves.append(b)
self.listVertice[a].insereVizinho(b, cor)
self.listVertice[b].insereVizinho(a, cor)
def adicionaVertice(self, name):
if not self.existVert(name):
v1 = Vertice()
v1.name = name
self.vertices[v1.name] = v1
else:
print("Vertice {} já existe!".format(name))
def adjacentes(self, name):
verticesCopy = {}
for x in self.vertices[name].subVertices:
v = Vertice()
v.name = self.vertices[x].name
verticesCopy[v.name] = v
return verticesCopy
def copyVertices(self):
verticesCopy = {}
for x in self.vertices:
v = Vertice()
v.name = self.vertices[x].name
verticesCopy[v.name] = v
return verticesCopy
def umVertice(self):
v = Vertice()
index = randint(0, self.ordem() - 1)
for x in self.vertices:
if index == 0:
v.name = self.vertices[x].name
return v
index -= 1
return v
def cargarDesdeMatriz(self, Matriz, Demanda):
#for fila in range(0, len(Matriz)):
# self._V.append(Vertice(fila+1, Demanda[fila])) #V=[1,3,4] A=[(1,3)(3,4)] => sol 1->3->4->5->2
for fila in range(0, len(Matriz)):
self._V.append(Vertice(fila+1, Demanda[fila])) #V=[1,3,4] A=[(1,3)(3,4)] => sol 1->3->4->5->2
for columna in range(0, len(Matriz[fila])):
aux = Arista(Vertice(fila+1, Demanda[fila]),Vertice(columna+1, Demanda[columna]),(Matriz[fila][columna]))
aux.setId(fila, columna, len(Matriz))
self._A.append(aux)
def cargaVertices(self, secuencia, sinVerticeInicial):
V = []
if (sinVerticeInicial):
for x in secuencia:
V.append(Vertice(int(x) + 1, self._demanda[x]))
else:
for x in secuencia:
V.append(Vertice(int(x), self._demanda[x - 1]))
return V
def geraVertices(self, listaVertices, numeroDeVertices):
vertices = {} # cria lista para armazenar todos os vertices
for i in range(numeroDeVertices):
vertices[i] = Vertice(
i, listaVertices[i]
) # inicializa cada vertice com seu respectivo indice e valor, e adiciona o mesmo na lista
return vertices # retorna a lista de vertices
def lerGrafoDoArquivoGr(arquivo: str, bipartido: bool):
f = open(arquivo, "r", encoding='utf-8')
linhas = f.readlines()
f.close()
grafo = None
for i in range(0, len(linhas)):
valores = linhas[i].split(" ")
if valores[0] == "p":
numVertices = int(valores[2])
vertices = list(
map(lambda v: Vertice(v, str(v)),
range(1, numVertices + 1)))
if valores[1] == "max":
grafo = GrafoDirigido(vertices)
elif valores[1] == "edge":
if bipartido:
grafo = GrafoBipartido(vertices)
else:
grafo = GrafoNaoDirigido(vertices)
elif valores[0] == "a" or valores[0] == "e":
v1 = grafo.vertices[int(valores[1]) - 1]
v2 = grafo.vertices[int(valores[2]) - 1]
peso = 1
if (len(valores) >= 4):
peso = float(valores[3])
grafo.adicionarRelacao(v1, v2, peso)
if bipartido:
grafo.lerParticoes()
return grafo
def insertarV(self, valor):
''' Metodo para insertar un vertice dentro de la lista de
Vertices
Args:
valor(objeto): el valor(informacion) contendra el vertice
'''
self.__Vertices.append( Vertice(valor) )
def __extract_vertices(self, lines):
from Vertice import Vertice
clean_lines = self.__clean_lines(lines)
vertices = {}
for vertex in clean_lines:
vertices[vertex[0]] = Vertice(vertex[1], vertex[2], vertex[3])
return vertices
def criarRedeResidual(grafo: GrafoDirigido):
vertices = list(map(lambda v: Vertice(v.numero, v.rotulo), grafo.vertices))
redeResidual = GrafoDirigido(vertices)
for arco in grafo.relacoes.values():
redeResidual.adicionarRelacao(arco.v1, arco.v2, arco.peso)
redeResidual.adicionarRelacao(arco.v2, arco.v1, 0)
return redeResidual
def newVertice(self, nome): # cria um novo vertice
for vt in self.vertices:
if vt.nome == nome:
print('Esse vértice já existe')
return False
else:
v = Vertice(nome)
self.vertices.append(v)
def __criaVertice(self, u):
# Verifica se o vértice u é novo (ou seja: nao foi encontrado
# no grafo)
if (self._obtemPosicao(u) == -1):
vertice = Vertice(u)
self.__lista.append(vertice)
self.__posicoes[str(u)] = self.__lista.index(vertice)
def inserirVerticesArtificiaisSeNecessario(grafo: GrafoDirigido):
vertices = list(map(lambda v: Vertice(v.numero, v.rotulo), grafo.vertices))
maiorNumVertice = max(map(lambda v: v.numero, vertices))
novoGrafo = GrafoDirigido(vertices)
for key in grafo.relacoes:
if key not in novoGrafo.relacoes:
arcoAtual = grafo.relacoes[key]
novoGrafo.adicionarRelacao(arcoAtual.v1, arcoAtual.v2, arcoAtual.peso)
idArcoRetorno = grafo.gerarIdRelacao(arcoAtual.v2, arcoAtual.v1)
if idArcoRetorno in grafo.relacoes:
maiorNumVertice = maiorNumVertice + 1
vertice = Vertice(maiorNumVertice, "Artificial " + str(maiorNumVertice))
novoGrafo.vertices.append(vertice)
novoGrafo.adicionarRelacao(arcoAtual.v2, vertice.numero, arcoAtual.peso)
novoGrafo.adicionarRelacao(vertice.numero, arcoAtual.v1, arcoAtual.peso)
return novoGrafo
def solucionAlAzar(self):
inicio = self._G.getVerticeInicio()
indices_azar = random.sample( range(2,len(self._G.getV())+1), len(self._G.getV())-1)
alAzar = []
alAzar.append(inicio)
for i in indices_azar:
alAzar.append(Vertice(i,0))
return alAzar
def generateGraph(gDic):
"""
根据图字典生成图
:param gDic: 图字典
:return: 图
"""
graph = Graph()
vDic = {}
for srcId, dstDic in zip(gDic.keys(), gDic.values()):
for dstId, srcToDstValue in zip(dstDic.keys(), dstDic.values()):
srcValue, dstValue, weight = Graph.__transfromEdge__(
srcToDstValue)
srcVertice = vDic.get(srcId, Vertice(srcValue, id=srcId))
vDic[srcId] = srcVertice
dstVertice = vDic.get(dstId, Vertice(dstValue, id=dstId))
vDic[dstId] = dstVertice
graph.addEdge(Edge(srcVertice, dstVertice, weight=weight))
return graph
def __init__(self, num_vertices, num_aristas):
self.num_vertices = num_vertices
self.num_aristas = num_aristas
self.vertices = []
self.aristas = []
self.ordenado = False
self.max_ts = 0
for i in range(0, num_vertices):
vertice = Vertice(i)
self.vertices.append(vertice)
def __lerVertices(linhas):
numeroDeVertices = int(linhas[0].split(" ")[1])
vertices = []
for i in range(1, numeroDeVertices + 1):
linha = linhas[i]
posicaoEspaco = linha.index(" ")
numeroVertice = int(linha[0:posicaoEspaco])
posicaoInicioRotulo = posicaoEspaco + 2
posicaoFimRotulo = len(linha) - 2
rotulo = linha[posicaoInicioRotulo:posicaoFimRotulo]
vertices.append(Vertice(numeroVertice, rotulo))
return vertices
def criarGrafoTransposto(self):
vertices = list(
map(lambda v: Vertice(v.numero, v.rotulo),
self.vertices)) # para nao ficar na mesma posicao de memoria
novoGrafo = GrafoDirigido(vertices)
for key in self.relacoes:
arcoAtual = self.relacoes[key]
novoGrafo.adicionarRelacao(arcoAtual.v2, arcoAtual.v1,
arcoAtual.peso)
return novoGrafo
def __init__(self, vertices=[], arestas=[], orientado=True, valorado=False):
self.orientado = orientado
self.vertices = []
self.valorado = valorado
id = 0
for vertice in vertices:
self.vertices.append(Vertice(id, vertice))
id += 1
self.arestas = []
id = 0
for aresta in arestas:
self.addAresta(id, aresta[0], aresta[1], aresta[2] if self.valorado else 1)
id += 1
def __criaAresta(self, u, v, peso=1):
pos1 = self._obtemPosicao(u)
pos2 = self._obtemPosicao(v)
if (pos1 >= 0 and pos2 >= 0):
aux = self.__lista[pos1] # Vértice auxiliar
# Encontra o próximo elemento do vetor
while (aux != None and aux._obtemProximo() != None):
aux = aux._obtemProximo()
# Cria um nó na lista de u contendo o vértice v
aux._criaProximo(Vertice(self.__lista[pos2]._obtemNome(), peso))
# Modifica o último para apontar para nulo
prox = aux._obtemProximo()
prox._modificaProximo(None)
def solucionVecinosCercanos(self):
inicio = self._G.getV()[0]
matrizDist = self._G.getMatriz()
recorrido = []
visitados = []
recorrido.append(inicio) #Agrego el vertice inicial
visitados.append(0) #Agrego el vertice inicial
masCercano=0
for i in range(0,len(matrizDist)-1):
masCercano = self.vecinoMasCercano(matrizDist,masCercano, visitados) #obtiene la posicion dela matriz del vecino mas cercano
recorrido.append(Vertice(masCercano+1,0))
visitados.append(masCercano)
i
return recorrido
def cargaGrafoDesdeSec(self, secuencia):
V = []
self._A = []
costo = 0
demAcum = 0
self._demandaAcumulada = []
cap = 0
#for x in secuencia:
for i in range(0, len(secuencia)):
x = secuencia[i]
V.append(Vertice(int(x), self._demanda[x - 1]))
if i > 0:
Vfila = V[i - 1]
Vcol = V[i]
fila = Vfila.getValue() - 1
col = Vcol.getValue() - 1
dist = self.getMatriz()[fila][col] #Referencias en la matriz
new_edge = Arista(Vfila, Vcol, dist)
new_edge.setId(fila, col, len(self._matrizDistancias))
self._A.append(new_edge)
demAcum += new_edge.getOrigen().getDemanda()
self._demandaAcumulada.append(demAcum)
costo += dist
cap += Vfila.getDemanda()
self.setV(V)
Vfila = V[-1]
Vcol = V[0]
fila = Vfila.getValue() - 1
col = 0
dist = self.getMatriz()[fila][col]
new_edge = Arista(Vfila, Vcol, dist)
new_edge.setId(fila, col, len(self._matrizDistancias))
self._A.append(new_edge)
demAcum += new_edge.getOrigen().getDemanda()
self._demandaAcumulada.append(demAcum)
costo += dist
cap += Vfila.getDemanda()
self._costoAsociado = costo
return cap
def BFS(grafo, s):
listaAdj = grafo.adj
vertices = []
for i in range(0, grafo.ordem + 1):
vertices.append(Vertice(i, 0, float("inf"), -1))
vertices[s].cor = 1
vertices[s].distancia = 0
vertices[s].predecessor = -1
fila = []
fila.append(vertices[s])
while len(fila) != 0:
u = fila.pop(0)
uAdj = listaAdj[u.numVertice]
for x in uAdj:
if vertices[x].cor == 0:
vertices[x].cor = 1
vertices[x].distancia = u.distancia + 1
vertices[x].predecessor = u.numVertice
fila.append(vertices[x])
vertices[u.numVertice].cor = 2
return vertices
def addVertice(self, key, duracao):
self.numVertices = self.numVertices + 1
verticeAtual = Vertice(key, duracao)
self.vertList[key] = verticeAtual
return verticeAtual
def main():
dot = gv.Graph(format='png')
dot.node('A')
dot.node('B')
dot.node('C')
dot.node('D')
dot.node('E')
dot.edge('A', 'B')
dot.edge('A', 'C')
dot.edge('A', 'E')
dot.edge('B', 'C')
dot.edge('C', 'D')
dot.edge('C', 'E')
dot.edge('D', 'E')
print(dot.source)
filename = dot.render(filename='img/g1')
print(filename)
a = Vertice('A')
b = Vertice('B')
c = Vertice('C')
d = Vertice('D')
e = Vertice('E')
a.addVert(b)
a.addVert(c)
a.addVert(e)
b.addVert(c)
c.addVert(d)
c.addVert(e)
d.addVert(c)
g = Grafo()
print
graph(g)
print
g.addVertice(a)
g.addVertice(b)
g.addVertice(c)
g.addVertice(d)
g.addVertice(e)
g.addAresta(b, d)
print
print
print(graph(g))
def addVertice(self, chave):
self.numVertices += 1
novoVertice = Vertice(chave)
self.listaVertices[chave] = novoVertice
return novoVertice
# -*- coding: utf-8 -*-
from Graph import Graph
from Vertice import Vertice
from Edge import Edge
# d = {"a": {"aa": 11}, "b": {"bb": 22}}
#
# l = []
# for d1 in d.values():
# l += d1.values()
#
# print l
import random
vertices = [Vertice(v) for v in range(7)]
nodes = [vertices[i] for i in [random.randint(0, 6) for _ in range(14)]]
_edges = [Edge(nodes[i], nodes[i + 1]) for i in range(len(nodes) - 1)]
edges = []
for i in range(len(_edges) - 1):
same = False
for j in range(i + 1, len(_edges)):
isSameSrc = _edges[i].srcVertice.id == _edges[j].srcVertice.id
isSameDst = _edges[i].dstVertice.id == _edges[j].dstVertice.id
if isSameDst and isSameSrc:
same = True
if not same:
edges.append(_edges[i])
def novo_Vertice(self, identificador):
self.lista_Vertices.append(Vertice(identificador))