def setUp(self):
self.arr_tests = []
self.arr_tests.append(Grafo())
self.arr_tests[0].adiciona_vertice(0)
self.arr_tests[0].adiciona_vertice(1)
self.arr_tests[0].adiciona_vertice(2)
self.arr_tests[0].adiciona_vertice(3)
self.arr_tests[0].adiciona_vertice(4)
self.arr_tests[0].adiciona_vertice(5)
self.arr_tests[0].adiciona_vertice(6)
self.arr_tests[0].adiciona_aresta(0, 1)
self.arr_tests[0].adiciona_aresta(1, 2)
self.arr_tests[0].adiciona_aresta(1, 3)
self.arr_tests[0].adiciona_aresta(2, 5)
self.arr_tests[0].adiciona_aresta(3, 5)
self.arr_tests[0].adiciona_aresta(4, 5)
self.arr_tests.append(Grafo())
self.arr_tests[1].adiciona_vertice(0)
self.arr_tests[1].adiciona_vertice(1)
self.arr_tests[1].adiciona_vertice(2)
self.arr_tests[1].adiciona_vertice(3)
self.arr_tests[1].adiciona_aresta(0, 1)
self.arr_tests[1].adiciona_aresta(1, 2)
self.arr_tests[1].adiciona_aresta(2, 3)
self.arr_tests[1].adiciona_aresta(3, 1)
def _extraer_datos(handler):
"""Recibe: archivo, Devuelve: 2 grafos
Extrae los datos del archivo y los devuelve"""
#variables
fila = []
nodos_cant = 0
calles_cant = 0
i = 0 #indice generico
info_nodo = {} #donde guardo la informacion de los nodos
grafo_nodos = Grafo()
grafo_calles = Grafo()
#Cargo el manejador de csv
contenido_csv = csv.reader(handler, delimiter=",")
#obtengo la primer linea, que me dice cuantos -NODOS- son
fila = contenido_csv.next()
nodos_cant = int(fila[0])
#avanzo para obtener la primer fila de -NODOS-
fila = contenido_csv.next()
#obtengo los datos de los -NODOS-
for i in range(nodos_cant - 1):
#guardo la info del nodo
info_nodo[int(fila[0])] = {
'x': float(fila[1]),
'y': float(fila[2]),
'lon': float(fila[4]),
'lat': float(fila[3])
}
#avanzo una posicion si no estoy en el ultimo -NODO-
if i != nodos_cant:
fila = contenido_csv.next()
#obtengo la cantidad de -CALLES-
fila = contenido_csv.next()
calles_cant = int(fila[0])
#avanzo para obtener la primer fila de -CALLES-
fila = contenido_csv.next()
#obtengo los datos de las -CALLES-
for i in range(calles_cant - 1):
if int(int(fila[4])) not in grafo_nodos:
grafo_nodos.agregar_vertice(int(fila[4]))
if texto(fila[1]) not in grafo_calles:
grafo_calles.agregar_vertice(texto(fila[1]))
#Agrego las aristas
grafo_nodos.agregar_arista(int(fila[4]), int(fila[5]), int(fila[2]))
grafo_calles.agregar_arista(texto(fila[1]), int(fila[4]), int(fila[5]))
#Cuando son mano unica
if int(fila[3]) == 0:
if int(fila[5]) not in grafo_nodos:
grafo_nodos.agregar_vertice(int(fila[5]))
grafo_nodos.agregar_arista(int(fila[5]), int(fila[4]),
int(fila[2]))
#devuelvo los grafos e info_nodo
if i != calles_cant:
fila = contenido_csv.next()
return grafo_nodos, grafo_calles, info_nodo
def main():
# As variáveis abaixo representam os nomes dos arquivos contendo os grafos para cada exercício da atividade, sendo:
#
# - ARQUIVO_1 usado para testar Edmonds-Karp
# - ARQUIVO_2 usado para testar Hopcroft-Karp
# - ARQUIVO_3 usado para testar o algoritmo de coloração de vértices
#
# Para usar outros arquivos, basta apenas substituir o nome nas variáveis abaixo
ARQUIVO_1 = "db128-alt.gr" # Trocar para o nome do arquivo usado no exercício 1, dirigido e ponderado
ARQUIVO_2 = "gr128_10-alt.gr" # Trocar para o nome do arquivo usado no exercício 2, grafo bipartido, não-dirigido e não-ponderado
ARQUIVO_3 = "ex_grafo_2.txt" # Trocar para o nome do arquivo usado no exercício 3, não-dirigido e não-ponderado
EX_1_FONTE = 0
EX_1_SORVEDOURO = 127
print("------------------------------------------")
print("Exercício 1: Edmonds-Karp ")
print("------------------------------------------")
grafo = Grafo()
grafo.ler(ARQUIVO_1)
fluxo_maximo = algoritmos.edmonds_karp(grafo, EX_1_FONTE, EX_1_SORVEDOURO)
print(f"Fluxo máximo: {fluxo_maximo}")
print("\n")
print("------------------------------------------")
print("Exercício 2: Hopcroft-Karp")
print("------------------------------------------")
grafo = Grafo()
grafo.ler(ARQUIVO_2)
algoritmos.hopcroft_karp(grafo)
print("\n")
print("------------------------------------------")
print("Exercício 3: Coloração dos vertices")
print("------------------------------------------")
grafo = Grafo()
grafo.ler(ARQUIVO_3)
cores = algoritmos.lawler(grafo)
print(f"Cores mínimas: {cores}")
def main():
if (len(sys.argv) != 7):
raise Exception(
'Debe ingresar las coordenadas x,y de los espias y del aeropuerto')
spy1 = ' '.join([sys.argv[1], sys.argv[2]])
spy2 = ' '.join([sys.argv[3], sys.argv[4]])
aeropuerto = ' '.join([sys.argv[5], sys.argv[6]])
print "El espia 1 esta en posicion " + spy1
print "El espia 2 esta en posicion " + spy2
print "El aeropuerto esta en posicion " + aeropuerto + "\n"
grafo = Grafo()
grafo_con_distancias = Grafo()
llenar_grafo(grafo)
llenar_grafo(grafo_con_distancias, True)
# Punto 1
nodos, distancias = grafo.bfs(aeropuerto)
print "1) Resultado sin pesos en las aristas:"
print "Distancia espia 1 hasta aeropuerto: " + str(distancias[spy1])
print "Distancia espia 2 hasta aeropuerto: " + str(distancias[spy2])
print "Gana espia 1" if distancias[spy1] < distancias[
spy2] else "Gana espia 2"
print "\n"
# Punto 2
print "2) Resultado con pesos en las aristas:"
print "espia 1 hasta aeropuerto " + str(
grafo_con_distancias.distanciaMinima(spy1, aeropuerto))
print "espia 2 hasta aeropuerto " + str(
grafo_con_distancias.distanciaMinima(spy2, aeropuerto))
print "\n"
# Punto 4
# sin pesos
print "4)"
print "4)a) camino minimo sin pesos es:"
print "espia 1 hasta aeropuerto " + ', '.join(
obtener_camino_bfs(nodos, spy1))
print "espia 2 hasta aeropuerto " + ', '.join(
obtener_camino_bfs(nodos, spy2))
print "\n"
# con pesos
print "4)b) camino minimo con pesos es:"
print "espia 1 hasta aeropuerto " + str(
grafo_con_distancias.recorridoMinimo(spy1, aeropuerto))
print "espia 2 hasta aeropuerto " + str(
grafo_con_distancias.recorridoMinimo(spy2, aeropuerto))
def selecionaAlgoritmos(args):
grafo = Grafo(args['<arquivoDeGrafo>'])
grafoDirigido = GrafoDirigido(args['<arquivoDeGrafo>'])
verticeInicial = int(args['-s'] or 1)
verticeFinal = int(args['-t'] or -1)
executaTodos = not(args['-f'] or args['-e'] or args['-c'])
if args['-f'] or executaTodos:
if verticeFinal == -1:
print("\nExecutando Algoritmo de Fluxo Máximo (Edmonds-Karp) do" +
" vértice", verticeInicial, "até o vértice final")
else:
print("\nExecutando Algoritmo de Fluxo Máximo (Edmonds-Karp) do" +
" vértice", verticeInicial, "ao vértice", verticeFinal)
algoritmos.edmondsKarp(grafo, verticeInicial, verticeFinal)
if args['-e'] or executaTodos:
print("\nExecutando Algoritmo de " +
"Emparelhamento Máximo (Hopcroft-Karp)")
grafoDirigido = GrafoDirigido(args['<arquivoDeGrafo>'], bipartido=True)
algoritmos.hopcroftKarp(grafoDirigido)
if args['-c'] or executaTodos:
print("\nExecutando Algoritmo de Coloração de Vértices")
algoritmos.coloracao(grafo)
def complemento(self):
comp= Grafo()
for v in self.V:
for w in self.V:
if v != w and (v, w) not in self.E:
comp.conecta(v, w, 1)
return comp
def mst_kruskal(grafo, return_grafo_o_union_find):
if grafo is not None:
if not grafo.diretto:
union_find = UnionFind()
nodi = get_nodi(grafo)
for v in nodi:
make_set(v, union_find)
archi = get_archi(grafo, nodi)
archi.sort(key=lambda a: a.peso)
archi_mst = []
for e in archi:
x = find_set(e.sorgente)
y = find_set(e.destinazione)
if x is not y:
union(x, y, union_find)
archi_mst.append(e)
if return_grafo_o_union_find == "union_find":
return union_find
elif return_grafo_o_union_find == "grafo":
mst_matrix = archi_to_matrix(archi_mst, False, len(nodi))
mst = Grafo(mst_matrix, len(nodi), False)
return mst
else:
print(
"Tipo di ritorno non riconosciuto. Serve \"grafo\" o \"union_find\""
)
return None
else:
print("Kruskal può essere eseguito solo su grafi indiretti")
return None
else:
print("Grafo non valido")
return None
def grafo_crear(nombre_archivo):
"""
Crea un grafo de conexiones de actores a partir de un archivo de datos.
PRE: Recibe el nombre de un archivo separado por comas que contenga de lineas:
actor,pelicula,pelicula,pelicula
que equivalen a: vertice,arista,arista,arista
POST: Devuelve un grafo creado a partir de estos datos.
"""
grafo = Grafo()
aristas = grafo.get_aristas()
with open(nombre_archivo, "r", encoding='utf-8', newline='\n') as csvfile:
actores_csv = csv.reader(csvfile)
for linea in actores_csv:
actor = linea[0]
grafo.agregar_vertice(actor)
for pelicula in linea[1:]:
actores = aristas.get(pelicula)
if actores:
for aux in actores:
grafo.agregar_arista(actor, aux, pelicula)
else:
aristas[pelicula] = [actor]
return grafo
def arbol_tendido_minimo(grafo):
'''
Obtiene un arbol de tendido minimo de un arbol.
grafo: el grafo fue creado.
Devuelve un nuevo grafo que representa un arbol de tendido
minimo del original.
'''
inicio = grafo.obtener_vertice_aleatorio()
visitados = {}
visitados[inicio] = True
heap = []
arbol = Grafo(True)
for v in grafo.obtener_adyacentes(inicio):
peso_arista = grafo.obtener_peso_union(inicio, v)
heappush(heap, (peso_arista, (inicio, v)))
for v in grafo:
arbol.agregar_vertice(v)
while heap:
dato = heappop(heap)
peso_arista = dato[PESO]
actual = dato[VERTICE][ACTUAL]
proximo = dato[VERTICE][PROXIMO]
if proximo in visitados:
continue
arbol.agregar_arista(actual, proximo, peso_arista)
visitados[proximo] = True
for u in grafo.obtener_adyacentes(proximo):
heappush(heap,
(grafo.obtener_peso_union(proximo, u), (proximo, u)))
return arbol
def cargar_en_grafo(archivoMapa, lineaEspia1, lineaEspia2, lineaAeropuerto,
distancia):
'''Carga el mapa en un grafo, y devuelve los puntos donde se encuentran el espia 1, 2 y el aeropuerto.
Si se produjo un error con el archivoMapa se informa '''
pos_espia_1 = -1
pos_espia_2 = -1
pos_aeropuerto = -1
grafo = Grafo()
try:
archivo = open(archivoMapa)
nroLinea = 0
for linea in archivo: #'p1.x p1.y - p2.x p2.y'
puntos = linea.split(' - ') #['p1.x p1.y','p2.x p2.y']
coordenadas = [puntos[0].split(), puntos[1].split()
] #[['p1.x','p1.y'],['p2.x','p2.y']
punto1 = (int(coordenadas[0][0]), int(coordenadas[0][1]))
punto2 = (int(coordenadas[1][0]), int(coordenadas[1][1]))
peso = distancia(punto1, punto2)
grafo.agregar_arista(punto1, punto2, peso)
if (nroLinea == lineaEspia1):
pos_espia_1 = punto1
if (nroLinea == lineaEspia2):
pos_espia_2 = punto1
if (nroLinea == lineaAeropuerto):
pos_aeropuerto = punto1
nroLinea += 1
except IOError, e:
print MSJ_ERROR, e
print MSJ_IOERROR, archivoMapa
raise IOError
def grafoDorogovtsevMendes(n, dirigido=False):
"""
Genera grafo aleatorio con el modelo Dorogovtsev-Mendes
:param n: número de nodos (≥ 3)
:param dirigido: el grafo es dirigido?
:return: grafo generado
"""
# Crear el grafo g
g = Grafo()
# Validar parámetros
if n < 3:
print("Solo valores n>=3")
return g
print("DorogovtsevMendes(" + str(n) + ")")
# Aregar 3 nodos y 3 aristas al grafo g, formando un triángulo
for i in range(3):
g.agreganodo(i)
g.agregaarista(0, 1)
g.agregaarista(0, 2)
g.agregaarista(1, 2)
# Agregar los siguientes nodos desde 3 hasta n al grafo g
for i in range(3, n):
g.agreganodo(i)
# Elegir una arista existente al azar
idx = random.randrange(0, i)
a = g.obtenerarista(idx)
# Agregar aristas entre el nuevo y los extremos de la arista elegida
g.agregaarista(i, int(a.src))
g.agregaarista(i, int(a.trg))
# Regresar el nodo g
return g
def grafo_crear(nombre_archivo):
"""
Crea un grafo de conexiones de actores a partir de un archivo de datos.
PRE: Recibe el nombre de un archivo separado por comas que contenga de lineas:
actor,pelicula,pelicula,pelicula
que equivalen a: vertice,arista,arista,arista
POST: Devuelve un grafo creado a partir de estos datos.
"""
grafo = Grafo()
with open(nombre_archivo
) as archivo: #Mas adelante habra que ver como manejar esto
#por lo del tema de que no entra en memoria...
peliculas = {}
for linea in archivo:
informacion = (linea.rstrip('\n')).split(',')
grafo.agregar_vertice(informacion[0])
for pelicula in informacion[1:]:
lista = peliculas.get(pelicula, [])
if not lista:
peliculas[pelicula] = lista
lista.append(informacion[0])
for pelicula, actores in peliculas.items():
for i in range(len(actores)):
for j in range(i + 1, len(actores)):
grafo.agregar_arista(actores[i], actores[j], pelicula)
#Es horrible el orden de esto pero no se me ocurrio nada mejor...
#Habra que ver otra forma de cambiarlo...
return grafo
def arbol_tendido_minimo(grafo):
"""Devuelve un nuevo grafo que representa un arbol de tendido minimo.
- Pre-condicion: recibe un grafo conexo."""
inicio = grafo.obtener_vertice_aleatorio()
visitados = set()
visitados.add(inicio)
heap = Heap()
for adyacente in grafo.obtener_vertices_adyacentes(inicio):
heap.encolar((inicio, adyacente),
grafo.obtener_peso_arista(inicio, adyacente))
arbol = Grafo()
for vertice in grafo.obtener_vertices():
arbol.agregar_vertice(vertice)
while not heap.esta_vacio():
[(vertice, adyacente), peso_arista] = heap.desencolar()
if adyacente in visitados:
continue
arbol.agregar_arista(vertice, adyacente, peso_arista)
visitados.add(adyacente)
for vecino in grafo.obtener_vertices_adyacentes(adyacente):
heap.encolar((adyacente, vecino),
grafo.obtener_peso_arista(adyacente, vecino))
return arbol
def main():
if len(sys.argv) != 3:
print("Cantidad de parámetros errónea")
return
flycombi = Grafo(no_dirigido)
with open(sys.argv[1], 'r') as aeropuertos:
reader = csv.reader(aeropuertos, delimiter=',')
for linea in reader:
if linea[0] in ciudades:
ciudades[linea[0]].append(linea[1])
else:
ciudades[linea[0]] = [linea[1]]
flycombi.agregar_vertice(linea[1])
flycombi.agregar_dato(linea[1], 'ciudad', linea[0])
with open(sys.argv[2], 'r') as vuelos:
reader = csv.reader(vuelos, delimiter=',')
for linea in reader:
peso = biblioteca_grafo.Peso(linea[2], linea[3], linea[4])
flycombi.agregar_arista(linea[0], linea[1], peso)
for operacion in sys.stdin:
if operacion[-1] == '\n':
operacion = operacion[:-1]
comando = operacion.split(" ", 1)
if not identificar_operacion(comando, flycombi):
print("Error en comando", comando[0])
return
def gera_grafo(df) -> Grafo:
global grafo
grafo = Grafo(df)
for i in range(len(colunas)):
# Pega o nome da cidade pelo índice
cidade_origem = colunas[i]
for j in range(len(colunas)):
# Pega o peso e o destino da aresta e adiciona no objeto Grafo
destino = df.index[j]
peso = df.iloc[j][cidade_origem]
#aresta = dict(rota=(cidade_origem, destino), peso=peso)
if peso != '-':
aresta = (int(cidade_origem), int(destino), int(peso))
grafo.adiciona_arestas(aresta)
fitness = mlrose.TravellingSales(distances=grafo.arestas)
# Define optimization problem object
problem_fit = mlrose.TSPOpt(length=8, fitness_fn=fitness, maximize=False)
best_state, best_fitness = mlrose.genetic_alg(problem_fit,
mutation_prob=0.2,
max_attempts=100,
random_state=2)
print(fitness)
return grafo
def ciudades() -> Grafo:
"""
Ejemplo 2: Ciudades
"""
albacete = 'Albacete'
alicante = 'Alicante'
cordoba = 'Córdoba'
madrid = 'Madrid'
valencia = 'Valencia'
# Crear grafo y agregar nodos, esta vez mediante el constructor
grafo = Grafo(albacete, alicante, cordoba, madrid, valencia)
# Conectar nodos con sus respectivas distancias
grafo.connect(albacete, alicante, 96)
grafo.connect(albacete, cordoba, 254)
grafo.connect(albacete, madrid, 100)
grafo.connect(albacete, valencia, 105)
grafo.connect(alicante, valencia, 110)
grafo.connect(cordoba, madrid, 102)
grafo.connect(madrid, valencia, 98)
imprimir_camino(grafo, cordoba, alicante)
return grafo
def test_vertice_pertenece(self):
#creo un grafo no dirigido
grafo = Grafo(False)
#le agrego un vértice
grafo.agregar_vertice("A")
#me fijo si el vértice pertenece o no al grafo
self.assertTrue(grafo.vertice_pertenece("A"))
def grafoGilbert(n, p, dirigido=False, auto=False):
"""
Genera grafo aleatorio con el modelo Gilbert
:param n: número de nodos (> 0)
:param p: probabilidad de crear una arista (0, 1)
:param dirigido: el grafo es dirigido?
:param auto: permitir auto-ciclos?
:return: grafo generado
"""
# Crear el grafo g
g = Grafo()
# Validar parámetros
if n <= 0 or p < 0 or p > 1:
print("Solo valores n>0 y 0<=p<=1")
return g
print("Gilbert(" + str(n) + ", " + str(p) + ")")
# Agregar n nodos
for nodo in range(n):
g.agreganodo(nodo)
# Para todos los pares de nodos diferentes, agregar las posibles aristas con probabilidad p
for u in range(n):
for v in range(n):
if random.random() <= p and u != v:
agregada = g.agregaarista(u, v)
else:
agregada = 0
# Regresar el grafo g
return g
def grafoGeografico(n, r, dirigido=False, auto=False):
"""
Genera grafo aleatorio con el modelo geográfico simple
:param n: número de nodos (> 0)
:param r: distancia máxima para crear un nodo (0, 1)
:param dirigido: el grafo es dirigido?
:param auto: permitir auto-ciclos?
:return: grafo generado
"""
# Crear grafo g
g = Grafo()
# Validar parámetros
if n <= 0 or r < 0 or r > 1:
print("Solo valores n>0 y 0<=r<=1")
return g
print("GeograficoSimple(" + str(n) + "," + str(r) + ")")
# Agregar n nodos al grafo g, cada nodo con coordenadas aleatorias
for i in range(n):
if g.agreganodo(i) == 1:
nodo = g.obtenernodo(i)
nodo.x = random.random()
nodo.y = random.random()
# Para cada par de nodos distintos, agregar la arista al grafo g si la distancia es menor que r
for i in range(n):
for j in range(n):
if i != j:
d = distancia(g.obtenernodo(i), g.obtenernodo(j))
if d <= r:
g.agregaarista(i, j)
# Regresar el grafo g
return g
def pruebas_camino_minimo():
print("PRUEBAS CAMINO MINIMO\n")
grafo = Grafo()
grafo.add_edge(1, 2)
grafo.add_edge(2, 3)
grafo.add_edge(3, 4)
camino = funciones.camino_minimo(grafo, 1, 4)
for v in camino[:-1]:
print(v, "-> ", end='')
print(camino[-1])
camino2 = funciones.camino_minimo(grafo, 2, 4)
for v in camino2[:-1]:
print(v, "-> ", end='')
print(camino2[-1])
grafo.add_edge(2, 4)
camino = funciones.camino_minimo(grafo, 1, 4)
for v in camino[:-1]:
print(v, "-> ", end='')
print(camino[-1])
camino2 = funciones.camino_minimo(grafo, 2, 4)
for v in camino2[:-1]:
print(v, "-> ", end='')
print(camino2[-1])
grafo.add(5)
camino = funciones.camino_minimo(grafo, 1, 5)
print(camino)
def prueba_bfs():
grafo1 = Grafo(True)
vertices = ['A', 'B', 'C', 'D', 'E', 'F', 'G']
for v in vertices:
grafo1.agregar_vertice(v)
grafo1.agregar_arista(vertices[0], vertices[1])
grafo1.agregar_arista(vertices[0], vertices[2])
grafo1.agregar_arista(vertices[1], vertices[2])
grafo1.agregar_arista(vertices[2], vertices[3])
grafo1.agregar_arista(vertices[3], vertices[4])
grafo1.agregar_arista(vertices[3], vertices[5])
grafo1.agregar_arista(vertices[4], vertices[1])
recorrido = bfs(grafo1, vertices[0])
padres = recorrido[0]
orden = recorrido[1]
print_test("Prueba BFS el padre del origen es None",
not padres[vertices[0]])
print_test("Prueba BFS el orden del origen es 0", orden[vertices[0]] == 0)
print_test("Prueba BFS el padre del vertice 'B' es el correcto",
padres[vertices[1]] == vertices[0])
print_test("Prueba BFS el orden del vertice 'B' es el correcto",
orden[vertices[1]] == 1)
print_test("Prueba BFS el padre del vertice sin aristas es el correcto",
not padres[vertices[6]])
print_test("Prueba BFS el orden del vertice sin aristas es el correcto",
orden[vertices[6]] == 0)
def itinerario_cultural(archivo_itinerario, grafo_aeropuertos, aeropuertos):
'''Recibe un archivo existente con formato csv,
donde la primera linea incluye las ciudades que se desea visitar,
y las subsiguientes lineas indican qué ciudades deben ser visitadas antes de qué otras.
Imprime por salida estandar el orden en que deben ser visitadas y el recorrido que se debe realizar,
para que la cantidad de escalas sea mínima.
'''
with open(archivo_itinerario) as itinerario:
itinerario = csv.reader(itinerario)
ciudades = next(itinerario)
grafo_ciudades = Grafo(True, ciudades)
for ciudad_a, ciudad_b in itinerario:
grafo_ciudades.agregar_arista(ciudad_a, ciudad_b)
orden = orden_topologico_dfs(grafo_ciudades)
imprimir_camino(orden, ', ')
camino_total = []
for i in range(len(orden) - 1):
origen, destino = orden[i], orden[i + 1]
camino_min = camino_minimo(grafo_aeropuertos, aeropuertos, origen,
destino, True)
camino_total.extend(camino_min)
if i != len(orden) - 2:
camino_total.pop()
imprimir_camino(camino_min, SEP_CAMINO)
return camino_total
def main():
'''
Grafo nao-direcionado ponderado
'''
arestas = ((0, 1, 4), (1, 2, 7), (2, 3, 2), (3, 1, 2))
grafo = Grafo(arestas, False, True)
print(grafo)
print("Os vertices (0) e (1) sao ligados?", grafo.ligados(0, 1))
print("Vertices adjacentes ao vertice (1):", grafo.adjacentes(1))
print("Grau de entrada do vertice (2):", grafo.grau_entrada(2))
print("Grau de saida do vertice (3):", grafo.grau_saida(3))
print("Insercao do vertice (4)")
grafo.inserir_vertice(4)
print(grafo)
print("Insercao da aresta (4,0,7)")
grafo.inserir_aresta(4, 0, 7)
print(grafo)
print("Remoção da aresta (1,3,2)")
grafo.remover_aresta(1, 3, 2)
print(grafo)
print("Remoção do vertice (2)")
grafo.remover_vertice(2)
print(grafo)
print("Matriz de Adjacencia")
grafo.imprimir_matriz()
print(grafo)
def _fronteras():
PAISES = [
"ARG", "BRA", "URU", "CHI", "PER", "PAR", "BOL", "ECU", "VEN", "COL",
"SUR", "GUY", "GUF"
]
g = Grafo(False, PAISES)
g.arista("ARG", "URU")
g.arista("ARG", "CHI")
g.arista("ARG", "BOL")
g.arista("ARG", "BRA")
g.arista("ARG", "PAR")
g.arista("BRA", "URU")
g.arista("BRA", "PAR")
g.arista("BRA", "BOL")
g.arista("BRA", "SUR")
g.arista("BRA", "GUF")
g.arista("BRA", "GUY")
g.arista("BRA", "VEN")
g.arista("BRA", "COL")
g.arista("BRA", "PER")
g.arista("CHI", "BOL")
g.arista("CHI", "PER")
g.arista("PAR", "BOL")
g.arista("PER", "BOL")
g.arista("ECU", "PER")
g.arista("ECU", "COL")
g.arista("COL", "PER")
g.arista("COL", "VEN")
g.arista("VEN", "GUY")
g.arista("SUR", "GUY")
g.arista("SUR", "GUF")
return g
def itinerario(grafo_sedes, archivo_recomendaciones, mapa_kml):
"""Recibe un itinerario que nos indica cuales son las sedes que debemos
visitar antes que otras, y con ellas hace un nuevo grafo con el que
llama a orden topologico, para luego imprimir su reccorrido segun el
itinerario pasado."""
try:
with open(archivo_recomendaciones, "r") as recomendaciones:
lector = csv.reader(recomendaciones)
grafo_recomendaciones = Grafo()
for sede_1,sede_2 in lector:
if not grafo_recomendaciones.vertice_pertenece(sede_1):
grafo_recomendaciones.agregar_vertice(sede_1)
if not grafo_recomendaciones.vertice_pertenece(sede_2):
grafo_recomendaciones.agregar_vertice(sede_2)
if grafo_sedes.vertices_conectados(sede_1, sede_2):
grafo_recomendaciones.agregar_arista(sede_1, sede_2, grafo_sedes.obtener_peso_arista(sede_1, sede_2))
except OSError:
print("No se pudo abrir el archivo {}".format(archivo_recomendaciones))
return
recorrido = orden_topologico(grafo_recomendaciones)
if (recorrido): imprimir_recorrido(grafo_sedes, recorrido, 0)
crear_kml(grafo_sedes, "itinerario {}".format(archivo_recomendaciones), recorrido, mapa_kml)
def parse(file):
''' Parsea un archivo .pjk (que posee labels y pesos) a una estructura Grafo.
Primero se agregan los vértices, siendo:
- line[0] el número de vértices,
- line[1] el label.
Luego se agregan las aristas, siendo:
- line[0] el vértice origen,
- line[1] el vértice destino,
- line[2] el peso.
Devuelve el grafo.
'''
grafo = Grafo()
vert_dict = {
} # Diccionario de vértices con su número de vértice usado para
with open(
file,
"r") as f: # luego agregar las aristas según el número de vértice.
vertices = int(f.readline().split(' ')[1]) # Cantidad de vertices
for line in f: # Agrega los vertices
line = line.split('"')
grafo[line[1]] = {}
vert_dict[int(line[0])] = line[1]
if int(
line[0]
) == vertices: # Corta cuando llega al número de vertices predefinido
break
f.readline()
for line in f: # Agrega las aristas
line = line.split(' ')
line = [int(i) for i in line]
grafo.agregar_arista(vert_dict[line[0]], vert_dict[line[1]],
line[2])
return grafo
def main():
nome_arquivo = input("Digite o caminho do arquivo:")
# arquivo para leitura
arquivo = open(nome_arquivo, "r")
quantidade = int(arquivo.readline())
grafo = Grafo()
# salva os objetos criados para economizar espaco e utilizá-los
# na criação das arestas
vertices_criados = {}
primeiro_vertice = Vertice(1)
vertices_criados[1] = primeiro_vertice
grafo.adiciona_vertice(primeiro_vertice)
for i in range(2, quantidade + 1):
vertices_criados[i] = Vertice(i)
grafo.adiciona_vertice(vertices_criados[i])
for leitura in arquivo:
# separa dois valores pelo espaco
valores_vertices = leitura.split()
v1 = vertices_criados[int(valores_vertices[0])]
v2 = vertices_criados[int(valores_vertices[1])]
grafo.adiciona_aresta(v1, v2)
try:
resultado = encontrar_caminho_projetos(grafo, primeiro_vertice)
print("A solução para este problema é: ", resultado)
except Exception as ex:
print(ex)
def _actores():
actores_por_pelicula = {}
actores = set()
with open("actores_test.csv") as f:
for l in f:
splitted = l.strip().split(",")
actor = splitted[0]
actores.add(actor)
peliculas = splitted[1:]
for peli in peliculas:
if peli not in actores_por_pelicula:
actores_por_pelicula[peli] = []
actores_por_pelicula[peli].append(actor)
g = Grafo()
for peli in actores_por_pelicula:
if len(actores_por_pelicula[peli]) < 2:
continue
for i in range(len(actores_por_pelicula[peli])):
for j in range(i + 1, len(actores_por_pelicula[peli])):
if actores_por_pelicula[peli][i] not in g:
g.agregar_vertice(actores_por_pelicula[peli][i])
if actores_por_pelicula[peli][j] not in g:
g.agregar_vertice(actores_por_pelicula[peli][j])
g.arista(actores_por_pelicula[peli][i],
actores_por_pelicula[peli][j])
return g
def database(ruta_aeropuertos, ruta_vuelos):
"""
Recibe rutas de aeropuertos y vuelos para procesar la información y guardarla en memoria.
Devuelve el grafo ya armado.
"""
with open(ruta_aeropuertos) as aeropuertos, open(ruta_vuelos) as vuelos:
lector_aeropuertos = csv.reader(aeropuertos)
lector_vuelos = csv.reader(vuelos)
grafo_general = Grafo()
datos_aeropuertos = {
} #Ciudad y posición geográfica de cada aeropuerto.
aeropuertos_de_ciudades = {
} #Cuando me pasan por comando la ciudad busco los aeropuertos que tiene acá.
for ciudad, codigo, latitud, longitud in lector_aeropuertos:
grafo_general.agregar_vertice(codigo)
datos_aeropuertos[codigo] = datos_aeropuertos.get(
codigo, [ciudad, latitud, longitud])
aeropuertos_de_ciudades[ciudad] = aeropuertos_de_ciudades.get(
ciudad, [])
aeropuertos_de_ciudades[ciudad].append(codigo)
for origen, destino, tiempo, precio, cant_vuelos in lector_vuelos:
#Arista con formato (precio,tiempo,cant_vuelos)
grafo_general.agregar_arista(origen, destino,
(precio, tiempo, cant_vuelos))
grafo_general.agregar_arista(destino, origen,
(precio, tiempo, cant_vuelos))
return grafo_general, datos_aeropuertos, aeropuertos_de_ciudades
def main():
'''
Grafo nao-direcionado nao-ponderado
'''
arestas = ((0, 1), (1, 2), (0, 3), (2, 3), (3, 1))
grafo = Grafo(arestas)
print("Grafo nao-ponderado nao-direcionado")
print(grafo)
print("Busca em Profundidade:", grafo.busca_em_profundidade(0))
print("Busca em Largura:", grafo.busca_em_largura(1))
print("\nOs vertices (0) e (1) sao ligados?", grafo.ligados(0, 1))
print("Vertices adjacentes ao vertice (1):", grafo.adjacentes(1))
print("Grau de entrada do vertice (2):", grafo.grau_entrada(2))
print("Grau de saida do vertice (3):", grafo.grau_saida(3))
print("\nInsercao do vertice (4)")
grafo.inserir_vertice(4)
print(grafo)
print("Insercao da aresta (4,1)")
grafo.inserir_aresta(4, 1)
print(grafo)
print("Remoção da aresta (1,3)")
grafo.remover_aresta(1, 3)
print(grafo)
print("Remoção do vertice (2)")
grafo.remover_vertice(2)
print(grafo)
print("Matriz de Adjacencia")
grafo.imprimir_matriz()
print(grafo)