예제 #1
0
    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)
예제 #2
0
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
예제 #3
0
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}")
예제 #4
0
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))
예제 #5
0
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)
예제 #6
0
파일: GRAFO.py 프로젝트: danhertz/1729448MC
 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
예제 #7
0
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
예제 #8
0
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
예제 #9
0
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
예제 #10
0
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
예제 #11
0
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
예제 #12
0
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
예제 #13
0
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
예제 #14
0
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
예제 #15
0
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
예제 #16
0
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
예제 #17
0
 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"))
예제 #18
0
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
예제 #19
0
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)
예제 #21
0
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)
예제 #22
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
예제 #23
0
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)
예제 #24
0
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
예제 #25
0
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)
예제 #26
0
파일: parse.py 프로젝트: klaus993/7541TP3
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
예제 #27
0
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)
예제 #28
0
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
예제 #29
0
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
예제 #30
0
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)