def arvore_geradora_minima_prim(graph):
arv_minima = grafo.Grafo()
corte = grafo.Grafo()
#Definindo ponto inicial de onde será realizado algoritmo de prim
vertice_inicial = graph.vertices[0].copy()
corte.addVertice(vertice_inicial.copy()
) #Adicionado no corte o vertice e todas suas arestas
vertice_inicial.adjacentes.clear()
arv_minima.addVertice(
vertice_inicial) #Adicionado na arvore minima somente o vertice
while not verifica_arv_minima(graph, arv_minima):
aresta = seleciona_menor_aresta(corte)
peso = aresta[1].peso
corte.addVertice(graph.getVertice(aresta[1].vertice).copy(
)) #Adicionado no corte o vertice onde estava a aresta minima
aresta[0].adjacentes.clear()
aresta[1].adjacentes.clear()
arv_minima.addVertice(
aresta[1]
) #Adicionado na arvore somente o vertice da aresta minima
#Adicionando somente a aresta minima nos respectivos vertices
vertex1 = arv_minima.getVertice(aresta[0].vertice)
vertex2 = arv_minima.getVertice(aresta[1].vertice)
vertex1.peso = peso
vertex2.peso = peso
arv_minima.addAresta(vertex1, vertex2.copy())
arv_minima.addAresta(vertex2, vertex1.copy())
return arv_minima
def h(self, estado, tipo):
if tipo == 1:
self.expandir(estado)
if len(estado.antecessores) > 1:
primeiro = estado.antecessores[
0] # Garanto que o primeiro é a cidade inicial? SIM
ultimo = estado.antecessores[-1]
nos_agm = [primeiro] + estado.filhos + [ultimo]
else:
nos_agm = [self.estado_inicial] + estado.filhos
lista = []
for x in nos_agm:
lista.append(x.valor)
matriz = calculaMatriz(lista)
cidades = [i for i in xrange(1, (len(nos_agm) + 1))]
arestas = []
for c1 in cidades:
for c2 in cidades:
arestas.append((c1, c2, matriz[c1 - 1][c2 - 1]))
grafo = G.Grafo(cidades, arestas)
agm, custo = grafo.kruskal(
) #Gerar todas as arestas entre esses caras e executar o Kruskal
return custo
elif tipo == 2:
self.expandir(estado)
if len(estado.antecessores) > 1:
ultimo = estado.antecessores[-1]
nos_agm = estado.filhos + [ultimo]
else:
nos_agm = [self.estado_inicial] + estado.filhos
lista = []
for x in nos_agm:
lista.append(x.valor)
matriz = calculaMatriz(lista)
cidades = [i for i in xrange(1, (len(nos_agm) + 1))]
arestas = []
for c1 in cidades:
for c2 in cidades:
arestas.append((c1, c2, matriz[c1 - 1][c2 - 1]))
grafo = G.Grafo(cidades, arestas)
agm, custo = grafo.kruskal(
) # Gerar todas as arestas entre esses caras e executar o Kruskal
return custo
else:
return "ERRO: HEURISTICA INEXISTENTE!!!"
def main():
nom_archivo = sys.argv[1]
graf = grafo.Grafo()
with open(nom_archivo) as archivo:
cargar_vertices(archivo, graf)
if graf.cantidad_vertices():
realizar_comandos(graf)
def seriabilidade(escalonamento):
lista_passados = []
g = grafo.Grafo("serial")
for tj in escalonamento:
# Adiciona vertices no grafo
if tj.id not in g.vertices:
g.add_vertice(tj.id)
# Detecta leitura após escrita
if tj.operacao == 'R':
for ti in lista_passados:
if ti.id != tj.id and ti.operacao == 'W' and tj.atributo == ti.atributo:
g.conectar(ti.id, tj.id)
# Detecta escrita após leitura
if tj.operacao == 'W':
for ti in lista_passados:
if ti.id != tj.id and ti.operacao == 'R' and tj.atributo == ti.atributo:
g.conectar(ti.id, tj.id)
# Detecta escrita após escrita
if tj.operacao == 'W':
for ti in lista_passados:
if ti.id != tj.id and ti.operacao == 'W' and tj.atributo == ti.atributo:
g.conectar(ti.id, tj.id)
lista_passados.append(tj)
return g
def setUp(self):
self.g = grafo.Grafo()
self.v1 = grafo.Vertice("A", 6)
self.v2 = grafo.Vertice("B", 6)
self.v3 = grafo.Vertice("C", 6)
self.v4 = grafo.Vertice("D", 6)
self.v5 = grafo.Vertice("E", 6)
self.v6 = grafo.Vertice("F", 4)
self.v7 = grafo.Vertice("G", 4)
self.v8 = grafo.Vertice("H", 4)
self.v9 = grafo.Vertice("I", 4)
self.g.add_vertice(self.v1)
self.g.add_vertice(self.v2)
self.g.add_vertice(self.v3)
self.g.add_vertice(self.v4)
self.g.add_vertice(self.v5)
self.g.add_vertice(self.v6)
self.g.add_vertice(self.v7)
self.g.add_vertice(self.v8)
self.g.add_vertice(self.v9)
self.g.conecta(self.v1, self.v4)
self.g.conecta(self.v1, self.v5)
self.g.conecta(self.v2, self.v5)
self.g.conecta(self.v3, self.v6)
self.g.conecta(self.v4, self.v7)
self.g.conecta(self.v5, self.v8)
self.g.conecta(self.v6, self.v9)
self.g.conecta(self.v6, self.v8)
def cargarRedDesdeArchivo(nombreArchivo):
red = grafo.Grafo()
with open(nombreArchivo, 'rb') as fd:
graphReader = csv.reader(fd)
for row in graphReader:
if(len(row) == 5):
nodo = grafo.Nodo(row[0],row[1])
red.ingresar_nodo(nodo)
elif(len(row)==2):
red.ingresar_arista(row[0], row[1])
return red
def prim(grafo, aeropuerto_origen, modo):
visitados = []
visitados.append(aeropuerto_origen)
heap = []
arbol = g.Grafo()
vertice_actual = grafo.obtener_vertice(aeropuerto_origen)
peso_total = 0
for adyacente in vertice_actual.obtener_adyacentes().keys():
if modo == "barato":
peso_arista = grafo.obtener_precio(aeropuerto_origen, adyacente)
else:
peso_arista = grafo.obtener_tiempo(aeropuerto_origen, adyacente)
heapq.heappush(heap, (peso_arista, adyacente, aeropuerto_origen))
for v in grafo.obtener_todos_vertices().values():
arbol.agregar_vertice(v.obtener_ciudad(), v.obtener_codigo(), 0, 0)
while heap:
v = heapq.heappop(heap)
if grafo.obtener_ciudad(v[1]) in visitados:
continue
if modo == "barato":
arbol.agregar_arista(v[1], v[2], 0, v[0], 0)
else:
arbol.agregar_arista(v[1], v[2], v[0], 0, 0)
visitados.append(grafo.obtener_ciudad(v[1]))
vertice_actual = grafo.obtener_vertice(v[1])
for key in vertice_actual.obtener_adyacentes().keys():
ciudad_adyacente = grafo.obtener_ciudad(key)
if ciudad_adyacente not in visitados:
if modo == "barato":
a_guardar = grafo.obtener_precio(v[1], key)
else:
a_guardar = grafo.obtener_tiempo(v[1], key)
peso_total += int(a_guardar)
heapq.heappush(heap, (a_guardar, key, v[1]))
return arbol, peso_total
def cargar_grafo(NOMBRE_ARCHIVO, CANTIDAD_ARTICULOS):
try:
archivo = open(NOMBRE_ARCHIVO, 'r')
grafo_wiki = grafo.Grafo(True)
archivo.readline()
for n in range(CANTIDAD_ARTICULOS):
linea = archivo.readline()
header, resto = linea.split('>')
grafo_wiki[header] = None
archivo.seek(0)
archivo.readline()
for n in range(CANTIDAD_ARTICULOS):
linea = archivo.readline()
header, resto = linea.split('>')
lista_links = resto.split('<')
for link in lista_links:
if link in grafo_wiki:
grafo_wiki.agregar_arista(header, link)
archivo.close()
return grafo_wiki
except FileNotFoundError:
raise
def tabuleiro_para_grafo(self, jogo):
# letras = string.ascii_lowercase
numeros = list(range(jogo.tamanho**2))
g = grafo.Grafo(list(numeros[:jogo.tamanho**2]))
g._grafo = defaultdict(lambda: defaultdict(int))
matriz = []
for i in range(0, jogo.tamanho**2, jogo.tamanho):
matriz.append(numeros[i:i + jogo.tamanho])
for x in range(jogo.tamanho):
for y in range(jogo.tamanho):
casa_atual = jogo.casa(x, y)
if wumpus.CACADOR in casa_atual:
self.vertice_cacador = matriz[x][y]
if wumpus.OURO in casa_atual:
self.vertice_ouro = matriz[x][y]
if 0 <= x < jogo.tamanho - 1:
casa_proxima = jogo.casa(x + 1, y)
g.add_aresta((matriz[x][y], matriz[x + 1][y],
self._calcula_custo(casa_atual,
casa_proxima)))
if 0 < x <= jogo.tamanho - 1:
casa_anterior = jogo.casa(x - 1, y)
g.add_aresta((matriz[x][y], matriz[x - 1][y],
self._calcula_custo(casa_atual,
casa_anterior)))
if 0 <= y < jogo.tamanho - 1:
casa_direita = jogo.casa(x, y + 1)
g.add_aresta((matriz[x][y], matriz[x][y + 1],
self._calcula_custo(casa_atual,
casa_direita)))
if 0 < y <= jogo.tamanho - 1:
casa_esquerda = jogo.casa(x, y - 1)
g.add_aresta((matriz[x][y], matriz[x][y - 1],
self._calcula_custo(casa_atual,
casa_esquerda)))
return g
def crear_grafo_archivo(archivo):
'''Esta funcion se encarga de cargar los archivos del grafo, primero recorre todos los vertices del archivo y guarda en un diccionario auxiliar el nro de
id como clave y el nombre del personaje como dato y guarda en el diccionario vertices el nombre como lcave y como dato crea otro diccionario para los
adyacentes.
Después recorre todas las aristas y se fija en el diccionario auxiliar cual es el nombre del personaje con el nro de id obtenido y lo busca en el diccionario
de vertices y le asigna a su diccionario de adyacentes la clave como el nombre del personaje que esta conectado (que también se busca en el dic_auxiliar)
y como dato el peso de la arista '''
with open(archivo, "r") as archivo_lectura:
linea = archivo_lectura.readline()
linea = archivo_lectura.readline() #Hago esto para que arranque a leer desde la linea despues de *Vertices
cont_vertices = 0
vertices = {} #Este diccionario gaurda como clave el nombre del personaje y como valor un diccionario de sus adyacentes
dic_auxiliar = {} #Este diccionario contiene el ID del personaje como clave y el nombre como valor
while "*Arcs" not in linea:
aux = linea.split('"')
nro_id = aux[0].rstrip(' ')
dic_auxiliar[nro_id] = aux[1]
vertices[aux[1]] = {}
cont_vertices += 1
linea = archivo_lectura.readline()
linea = archivo_lectura.readline()
cont_aristas = 0
while (linea):
linea = linea.rstrip('\n')
arista = linea.split(' ')
vertices[dic_auxiliar[arista[0]]][dic_auxiliar[arista[1]]] = float(arista[2])
vertices[dic_auxiliar[arista[1]]][dic_auxiliar[arista[0]]] = float(arista[2])
cont_aristas += 1
linea = archivo_lectura.readline()
grafo_marvel = grafo.Grafo(vertices, False, cont_vertices, cont_aristas)
return grafo_marvel
import grafo
mapa1 = grafo.Grafo()
for a in range(5):
mapa1.add_nodo()
mapa1.add_arco(0, 1, 10)
mapa1.add_arco(1, 0, 10)
mapa1.add_arco(1, 2, 10)
mapa1.add_arco(2, 1, 10)
mapa1.add_arco(1, 3, 10)
mapa1.add_arco(3, 1, 10)
mapa1.add_arco(2, 3, 10)
mapa1.add_arco(3, 2, 10)
if mapa1.hay_camino(4, 4):
print "Hay camino de 4 a 4"
if mapa1.hay_camino(1, 4):
print "Hay camino de 1 a 4"
import grafo as gra
from datetime import datetime
""" Crear un Grafo Vacio """
print(" Creando un Grafo Vacio ")
prueba = gra.Grafo(0)
""" agregando los nodos """
print(" agregando los nodos ")
c = 0
while (c < 101):
numnodo = prueba.add_nodo()
c += 1
""" Agregando Arcos """
print(" Agregando Arcos ")
prueba.add_arco(0, 6, 8)
prueba.add_arco(0, 9, 7)
prueba.add_arco(1, 2, 3)
prueba.add_arco(2, 1, 2)
prueba.add_arco(2, 3, 7)
prueba.add_arco(2, 5, 10)
prueba.add_arco(3, 4, 6)
prueba.add_arco(3, 7, 9)
prueba.add_arco(4, 2, 5)
prueba.add_arco(4, 8, 6)
prueba.add_arco(4, 5, 2)
prueba.add_arco(5, 4, 1)
prueba.add_arco(5, 6, 2)
prueba.add_arco(6, 5, 10)
prueba.add_arco(6, 7, 2)
prueba.add_arco(6, 9, 4)
prueba.add_arco(7, 0, 10)
prueba.add_arco(7, 6, 3)
try:
archivo = sys.argv[1]
except IndexError:
print("ingrese nombre archivo: \n$ python3.x krustal.py nombre_archivo")
exit()
try:
modo = sys.argv[2]
except IndexError:
print("ingrese modo: \n$ python3.x krustal.py nombre_archivo modo")
exit()
g = leer_grafo(archivo)
grafo = grafo.Grafo(g)
if modo == 'arbol':
lst = List_Set_T()
elif modo == 'listah':
lst = List_Set(1)
elif modo == 'lista':
lst = List_Set()
else:
print("modo no valido")
exit()
#ordena por peso
grafo.sort()
#Kruskal
A = set()
ES = grafo.Aristas()
import dados2 import grafo grafo = grafo.Grafo(dados2.matriz7) grafo.caminharGrafo()