def getShortestCoordinate(analyzer, estacionCercanaInicio, estacionCercanaFinal): """ Devuelve la ruta entre una coordenada origen y una final """ lista = [] suma = 0 estructura1 = dfs.DepthFirstSearch(analyzer["trips"], estacionCercanaInicio) estructura2 = dfs.DepthFirstSearch(analyzer["trips"], estacionCercanaFinal) if dfs.hasPathTo(estructura1, estacionCercanaFinal): camino = dfs.pathTo(estructura1, estacionCercanaFinal) getPathNextStations(lista, camino["first"]) lista.append(camino["last"]["info"]) for i in range(1, len(lista)): suma += gr.getEdge(analyzer["trips"], lista[i - 1], lista[i])["weight"] elif dfs.hasPathTo(estructura2, estacionCercanaInicio): camino = dfs.pathTo(estructura1, estacionCercanaInicio) getPathNextStations(lista, camino["first"]) lista.append(camino["last"]["info"]) for i in range(1, len(lista)): suma += gr.getEdge(analyzer["trips"], lista[i - 1], lista[i])["weight"] lista = reverseList(lista) else: suma = -1 return (lista, suma)
def requerimiento4(time, InitialS, citibike): time = int(time) #Cambio S-M listD = gr.vertices(citibike["graph"]) Recorrido = dfs.DepthFirstSearch(citibike["graph"], InitialS) ListaPilas = lt.newList('SINGLE_LINKED', compareIds) for i in range(1, lt.size(listD) + 1): vertice2 = lt.getElement(listD, i) if dfs.pathTo(Recorrido, vertice2) and InitialS != vertice2: Pila = dfs.pathTo(Recorrido, vertice2) lt.addLast(ListaPilas, Pila) ## Se buscan los Vertices que se conecten a Initial S listadeciclos = lt.newList('SINGLE_LINKED', compareIds) for r in range(1, lt.size(ListaPilas) + 1): listanueva = lt.newList('SINGLE_LINKED', compareIds) pila = lt.getElement(ListaPilas, r) for j in range(1, stack.size(pila) + 1): k = stack.pop(pila) lt.addLast(listanueva, k) lt.addLast(listadeciclos, listanueva) listaF = lt.newList('SINGLE_LINKED', compareIds) for i in range(1, lt.size(listadeciclos) + 1): EstacionesI = 0 Viaje = lt.newList('SINGLE_LINKED', compareIds) ciclo = lt.getElement(listadeciclos, i) peso = 0 for j in range(1, lt.size(ciclo)): verticeA = lt.getElement(ciclo, j) Ultimo = lt.lastElement(ciclo) verticeB = lt.getElement(ciclo, (j + 1)) arco = gr.getEdge(citibike["graph"], verticeA, verticeB) EstacionesI += 1 peso += int(arco["weight"]) lt.addLast(Viaje, EstacionesI) lt.addLast(Viaje, Ultimo) peso = peso / 60 lt.addLast(Viaje, peso) if peso <= time: lt.addLast(listaF, Viaje) if lt.isEmpty(listaF): return False else: return listaF
def req4(catalog): grafo = catalog["connections"] initSearch = prim.initSearch(grafo) search = prim.prim(grafo, initSearch, "Washington, D.C.") mst = gr.newGraph(datastructure="ADJ_LIST", size=3000, directed=False, comparefunction=compareIds) landing_points = mp.newMap(numelements=1249, maptype="PROBING", loadfactor=0.3) vertices = mp.keySet(search["marked"]) for vertice in lt.iterator(vertices): lp = vertice.split("|")[0] mp.put(landing_points, lp, None) gr.insertVertex(mst, vertice) listaArcos = mp.keySet(search["edgeTo"]) pesoTotal = 0 for verticeB in lt.iterator(listaArcos): verticeA = mp.get(search["edgeTo"], verticeB)["value"]["vertexA"] peso = mp.get(search["edgeTo"], verticeB)["value"]["weight"] gr.addEdge(mst, verticeA, verticeB, peso) pesoTotal += peso dfsSearch = dfs.DepthFirstSearch(mst, "Washington, D.C.") maxArcos = 0 arcos = None for vertice in lt.iterator(vertices): pathTo = dfs.pathTo(dfsSearch, vertice) if pathTo: numArcos = lt.size(pathTo) if numArcos > maxArcos: maxArcos = numArcos arcos = pathTo numLanding_points = gr.numEdges(mst) + 1 return numLanding_points, pesoTotal, arcos
def rutaCircular(analyzer, estacion, tiempoin, tiempofin): if m.get(analyzer['stationsStart'],estacion) is not None: lista1 = lt.newList("ARRAY_LIST") adyacentes = gr.adjacents(analyzer['graph'], estacion) connectedComponents(analyzer) for h in range (adyacentes['size']): adyacente= lt.getElement(adyacentes,h) fcc = sameCC(analyzer, estacion, adyacente) if fcc: tiempo=0 analyzer['paths'] = dfs.DepthFirstSearch(analyzer["graph"], adyacente) caminos = dfs.pathTo(analyzer["paths"], estacion) primero= caminos['first'] siguiente = primero['next'] for i in range(caminos['size']-1): infoin = primero['info'] if siguiente is not None: infoul = siguiente['info'] arco = gr.getEdge(analyzer["graph"], infoin, infoul) if arco is not None: tiempo += float(arco["weight"]) primero = primero['next'] siguiente = siguiente['next'] suma = float(caminos['size'])*1200 tiempo+=suma lt.addLast(caminos,tiempo) lt.addLast(lista1, caminos) listafinal= lt.newList("ARRAY_LIST") if lista1 is not None: tmi = int(tiempoin)*60 tmf = int(tiempofin)*60 while (not stack.isEmpty(lista1)): parada = stack.pop(lista1) if float(parada['last']['info']) >= tmi and float(parada['last']['info']) <= tmf: lt.addLast(listafinal, parada) print("la cantidad de rutas es : "+ str(listafinal['size'])) for i in range( listafinal['size'] ): actual = lt.getElement(listafinal,i) print("ruta no: "+ str(i+1)) for j in range(actual['size']-1): info= m.get(analyzer['stationsStart'], lt.getElement(actual,j))['value'] print(str(j+1)+". " + info["nombre"]) print("con una duracion estimada de: "+str(int(actual['last']['info'])/60)+" minutos")
def ruta_ciclica(analyzer, estacion, tiempo): recorrido = scc.KosarajuSCC(analyzer['graph']) #recorrido = dfs.DepthFirstSearch(analyzer['graph'], estacion) i = 0 j = 0 l = [] while i<len(recorrido['idscc']['table']['elements']): if str(recorrido['idscc']['table']['elements'][i]['key']) == str(estacion): v = recorrido['idscc']['table']['elements'][i]['value'] i += 1 #print(v) while j<len(recorrido['idscc']['table']['elements']): if str(recorrido['idscc']['table']['elements'][j]['value']) == str(v): l.append(str(recorrido['idscc']['table']['elements'][j]['key'])) j += 1 # l.append(recorrido['visited']['table']['elements'][i]['key']) # i += 1 #print(l) #return recorrido['visited']['table']['elements'] #print(recorrido['idscc']['table']['elements']) #print(l) k = 0 b = 1 while k<len(l) and b<(len(l)-1): df = dfs.DepthFirstSearch(analyzer['graph'], l[k]) camino = dfs.pathTo(df,l[b]) #if camino['size'] == 2: # peso_1 = gr.getEdge(analyzer['graph'],camino['first']['info'],camino['first']['info']['next']['info']) # print(peso_1) #else: #print(camino) #a = 0 #while a<len(df['visited']['table']['elements']): # if estacion == df['visited']['table']['elements'][a]['key']: # if df['visited']['table']['elements'][a]['value']['edgeTo'] == df['source']: # rutas_unicas.append(df['source']) k += 1 b += 1 return camino
def getCircularRoute(analyzer, stationId): lista2 = [] listaCamino = [] listaFinal = [] adjacents = gr.adjacents(analyzer["trips"], stationId) estructura = scc.KosarajuSCC(analyzer['trips']) iterator = it.newIterator(adjacents) while it.hasNext(iterator): element = it.next(iterator) if scc.stronglyConnected(estructura, stationId, element): lista2.append(element) for i in lista2: x = [stationId] nuevaEstructura = dfs.DepthFirstSearch(analyzer["trips"], i) camino = dfs.pathTo(nuevaEstructura, stationId) getPathNextStations(x, camino["first"]) x.append(stationId) listaCamino.append(x) for j in range(0, len(listaCamino) - 1): listaFinal.append( getStationToStation(listaCamino[j], analyzer["trips"])) return listaFinal
def caminos(analyzer, adyacentes_ciudad_cable): lista_caminos = lt.newList(datastructure="ARRAY_LIST") vertices = gr.vertices(analyzer["connections_capacity"]) i = 1 while i <= lt.size(adyacentes_ciudad_cable): adyacente = lt.getElement(adyacentes_ciudad_cable, i) dfs_adyacente = dfs.DepthFirstSearch(analyzer["connections_capacity"], adyacente) ii = 1 while ii <= lt.size(vertices): vertice = lt.getElement(vertices, ii) if vertice[1] == cable: verdad = dfs.hasPathTo(dfs_adyacente, vertice) camino = dfs.pathTo(dfs_adyacente, vertice) lt.addLast(lista_caminos, camino) ii += 1 i += 1 return lista_caminos
def req4(analyzer): estructura = pr.PrimMST(analyzer["connections_distance"]) costo_total = pr.weightMST(analyzer["connections_distance"], estructura) grafo_mst = gr.newGraph(datastructure='ADJ_LIST', directed=True, size=5000, comparefunction=None) i = 1 while i <= lt.size(estructura["mst"]): arista = lt.getElement(estructura["mst"], i) verticeA = arista["vertexA"] verticeB = arista["vertexB"] weight = arista["weight"] if not gr.containsVertex(grafo_mst, verticeA): gr.insertVertex(grafo_mst, verticeA) if not gr.containsVertex(grafo_mst, verticeB): gr.insertVertex(grafo_mst, verticeB) gr.addEdge(grafo_mst, verticeA, verticeB, weight) gr.addEdge(grafo_mst, verticeB, verticeA, weight) i += 1 num_vertices = gr.numVertices(grafo_mst) vertices_mst = gr.vertices(grafo_mst) inicio = lt.firstElement(estructura["mst"])["vertexA"] final = lt.lastElement(estructura["mst"])["vertexB"] estructura_dfs = dfs.DepthFirstSearch(grafo_mst, inicio) caminoo = dfs.pathTo(estructura_dfs, final) return num_vertices, costo_total, caminoo
def requerimiento2(citibike, tiempo, idestacion): listaadyacentes = gr.adjacentEdges( citibike["graph"], idestacion) ##Haya los arcos del Vertice Inicial ## listaestaciones = lt.newList('SINGLE_LINKED', compareIds) ##Crea Lista for i in range(1, lt.size(listaadyacentes) + 1): ##Hace un recorrido por la lista de arcos arco = lt.getElement(listaadyacentes, i) if arco["vertexA"] == idestacion: lt.addLast(listaestaciones, arco["vertexB"] ) ##Agrefa El vetice B de los Arcos Iniciales ## ##No necesito supachato = scc.KosarajuSCC(citibike["graph"]) fuertementeconectados = lt.newList('SINGLE_LINKED', compareIds) for i in range(1, lt.size(listaestaciones) + 1): verticeB = lt.getElement(listaestaciones, i) if scc.stronglyConnected(supachato, idestacion, verticeB): lt.addLast(fuertementeconectados, verticeB) ##Agrega los fuertemente conectados a una lista listadepilas = lt.newList('SINGLE_LINKED', compareIds) for i in range(1, lt.size(fuertementeconectados) + 1): vertice = lt.getElement(fuertementeconectados, i) matenme = dfs.DepthFirstSearch(citibike["graph"], vertice) pila = dfs.pathTo(matenme, idestacion) lt.addLast(listadepilas, pila) listadeciclos = lt.newList('SINGLE_LINKED', compareIds) for i in range(1, lt.size(listadepilas) + 1): listanueva = lt.newList('SINGLE_LINKED', compareIds) pila = lt.getElement(listadepilas, i) for j in range(1, stack.size(pila) + 1): k = stack.pop(pila) lt.addLast(listanueva, k) lt.addLast(listadeciclos, listanueva) listadefinitiva = lt.newList('SINGLE_LINKED', compareIds) for i in range(1, lt.size(listadeciclos) + 1): ciclo = lt.getElement(listadeciclos, i) peso = 0 for j in range(1, lt.size(ciclo)): verticeA = lt.getElement(ciclo, j) verticeB = lt.getElement(ciclo, (j + 1)) arco = gr.getEdge(citibike["graph"], verticeA, verticeB) peso += int(arco["weight"]) peso = peso + ((lt.size(ciclo)) * 1200) peso = peso / 60 if peso <= tiempo: lt.addLast(listadefinitiva, ciclo) if lt.isEmpty(listadefinitiva): return False else: return listadefinitiva
def test_dfs(graph): search = dfs.DepthFirstSearch(graph, 'Yopal') assert dfs.hasPathTo(search, 'Manizales') is True path = dfs.pathTo(search, 'Manizales') assert stk.size(path) == 7
def DFS_pathTo(search, vertex): return dfs.pathTo(search, vertex)
def revisar(citibike, estacion, rango1, rango2): revisar = scc.KosarajuSCC(citibike["graph"]) estacion_base = m.get(revisar["idscc"], estacion) valores = m.keySet(revisar["idscc"]) elegidos = lt.newList("ARRAY_LIST") for i in range(1, lt.size(valores) + 1): llave = lt.getElement(valores, i) if me.getValue(m.get(revisar["idscc"], llave)) == me.getValue(estacion_base): lt.addLast(elegidos, llave) grafo_SCC = { "graph": gr.newGraph( datastructure="ADJ_LIST", directed=True, size=lt.size(elegidos) + 1, comparefunction=compareStations, ) } for i in range(1, lt.size(elegidos) + 1): vertex = lt.getElement(elegidos, i) adyacentes = gr.adjacentEdges(citibike["graph"], vertex) for o in range(lt.size(adyacentes) + 1): arco_adyacente = lt.getElement(adyacentes, o) for e in range(1, lt.size(elegidos) + 1): comprueba = lt.getElement(elegidos, e) if arco_adyacente["vertexB"] == comprueba: addStation(grafo_SCC, vertex) addStation(grafo_SCC, comprueba) addConnection(grafo_SCC, vertex, comprueba, arco_adyacente["weight"]) search = dfs.DepthFirstSearch(grafo_SCC["graph"], estacion) anexo = djk.Dijkstra(grafo_SCC["graph"], estacion) arcos = gr.edges(grafo_SCC["graph"]) elegidos = [] caminos_candidatos_DFS = lt.newList("ARRAY_LIST") caminos_candidatos_DJK = lt.newList("ARRAY_LIST") for i in range(1, lt.size(arcos) + 1): arco = lt.getElement(arcos, i) if arco["vertexB"] == estacion: elegidos.append(arco["vertexA"]) for i in elegidos: caminoDFS_pila = dfs.pathTo(search, i) caminoDFS_lista = lt.newList("ARRAY_LIST") caminoDJK_pila = djk.pathTo(anexo, i) caminoDJK_list = lt.newList("ARRAY_LIST") caminoDJK_final = lt.newList("ARRAY_LIST") for e in range(1, lt.size(caminoDJK_pila) + 1): add = sta.pop(caminoDJK_pila) lt.addLast(caminoDJK_list, add) for e in range(1, lt.size(caminoDFS_pila) + 1): add = sta.pop(caminoDFS_pila) lt.addLast(caminoDFS_lista, add) if lt.size(caminoDJK_list) > 0: for e in range(1, lt.size(caminoDJK_list) + 1): elemento = lt.getElement(caminoDJK_list, e) if e == 1: lt.addLast(caminoDJK_final, elemento["vertexA"]) lt.addLast(caminoDJK_final, elemento["vertexB"]) else: lt.addLast(caminoDJK_final, elemento["vertexB"]) if lt.size(caminoDJK_final) > 0: lt.addLast(caminoDJK_final, estacion) lt.addLast(caminos_candidatos_DJK, caminoDJK_final) if lt.size(caminoDFS_lista) > 0: lt.addLast(caminoDFS_lista, estacion) lt.addLast(caminos_candidatos_DFS, caminoDFS_lista) caminos_finales_pesos = lt.newList("ARRAY_LIST") caminos_candidatos(caminos_candidatos_DJK, grafo_SCC, caminos_finales_pesos, rango1, rango2) caminos_candidatos(caminos_candidatos_DFS, grafo_SCC, caminos_finales_pesos, rango1, rango2) return caminos_finales_pesos
from DISClib.Algorithms.Graphs import dfs from DISClib.ADT import list as lt #Ejemplo uso de DFS def comparefunction(searchname, element): if (searchname == element['key']): return 0 elif (searchname < element['key']): return -1 return 1 grafo = gr.newGraph(datastructure='ADJ_LIST', directed=False, size=14000, comparefunction=comparefunction) #DFS gr.insertVertex(grafo, "a") gr.insertVertex(grafo, "b") gr.insertVertex(grafo, "c") gr.addEdge(grafo, "a", "b") gr.addEdge(grafo, "c", "b") search = dfs.DepthFirstSearch(grafo, "b") path = dfs.pathTo(search, "a") for v in lt.iterator(path): print(v)
def stationsbyres(citibike,idstation,time_max): tiempo = minToseconds(time_max) lista = lt.newList('ARRAY_LIST',compareLists) recorrido = dfs.DepthFirstSearch(citibike['graph'],idstation) #Recorrido por el gráfo con DFS llaves = m.keySet(recorrido['visited']) #Extracción llaves del recorrido iterador = it.newIterator(llaves) #Inicializar Iterador con las llaves while it.hasNext(iterador): id = it.next(iterador) path = dfs.pathTo(recorrido,id) #Encontrar el "path" entre el vertice y el de destino if path is not None: n_lista=lt.newList('ARRAY_LIST') nueva_lista = lt.newList('ARRAY_LIST') while (not stack.isEmpty(path)): ruta = stack.pop(path) #Como path es pila, retornar el tope de la fila lt.addLast(n_lista,ruta) #Agregar a n_lista, la ruta suma = 0 while lt.size(n_lista)> 1 : if suma<= tiempo: german = lt.getElement(n_lista,1) #Hallar vértice 1 hola = lt.getElement(n_lista,2) #Hallar vértice 2 arco = gr.getEdge(citibike['graph'],german,hola) #ENcontrar el arco entre 1 y 2 peso = arco['weight'] #Encontar el peso del arco suma += peso #Suma de los pesos c= lt.removeFirst(n_lista) #Extraigo el primero de la lista lt.addLast(nueva_lista,c) #Lo añado a nueva_lista else: break if lt.isPresent(lista,nueva_lista) == 0: #Si no esta presente nueva lista en lista, lo agregó if lt.size(nueva_lista)<= 1: pass else: lt.addLast(lista,nueva_lista) else: pass count = 1 for a in range(1,lt.size(lista)+1): l = lt.getElement(lista,a) #Accedo a las listas dentro de la lista grande if lt.size(l)==2: print("=========================================") print(bold + "RUTA NÚMERO: "+ end + str(count)) print("\n") verticea = lt.getElement(l,1) verticeb = lt.getElement(l,2) arco = gr.getEdge(citibike['graph'],verticea, verticeb)['weight'] #Encuentro el peso entre dos vertices changeInfo(citibike,l,1) changeInfo(citibike,l,2) print(bold + "Segmento de ruta: " + end) printListContent(l) #Imprime los segmentos de las rutas con la información de "l" print(bold + "Tiempo estimado del segmento: "+ end) convertSecondsToDate(arco) #Convierte los segundos a formato fecha print("\n") count+=1 else: print("=========================================") print(bold + "RUTA NÚMERO: " + end + str(count)) print("\n") while 1 < lt.size(l): ll = lt.newList('ARRAY_LIST') vertice1 = lt.getElement(l,1) vertice2 = lt.getElement(l,2) arco = gr.getEdge(citibike['graph'],vertice1, vertice2)['weight'] #Encuentro el peso entre dos verices lt.addLast(ll,vertice1) lt.addLast(ll,vertice2) changeInfo(citibike,ll,1) changeInfo(citibike,ll,2) print(bold + "Segmento ruta: " + end) printListContent(ll) print(bold + "Tiempo estimado del segmento: "+ end) convertSecondsToDate(arco) #Convierte los segundos a formato fecha print("\n") lt.removeFirst(l) count+=1 print("-------------------------------------------------------") print(bold + "TOTAL DE RUTAS ENCONTRADAS: " + end +str(count-1)) return None
def circulargraph(analyzer, StartStationid, avaibleTimemin, avaibleTimemax): r = {"R_Especifico": {}} rutas = 0 totalrutas = -1 Kosaraju = connectedComponents(analyzer) verticeslst = gr.vertices(analyzer['graph']) vertices = it.newIterator(verticeslst) bfs_startstation = dfs.DepthFirstSearch(analyzer['graph'], StartStationid) while it.hasNext(vertices): time = -20 vertice = it.next(vertices) if sameCC(analyzer, StartStationid, vertice): totalrutas += 1 if (gr.getEdge(analyzer['graph'], vertice, StartStationid)) != None: tiempo_vuelta = e.weight( gr.getEdge(analyzer['graph'], vertice, StartStationid)) tiempo_vuelta = tiempo_vuelta pila_ida = (dfs.pathTo(bfs_startstation, vertice)) v1 = st.pop(pila_ida) time += (20 * st.size(pila_ida)) while not st.isEmpty(pila_ida): v2 = st.pop(pila_ida) time += e.weight(gr.getEdge(analyzer['graph'], v1, v2)) v1 = v2 if time / 60 > avaibleTimemax: break else: bfs_backstation = dfs.DepthFirstSearch(analyzer['graph'], vertice) pila_ida = (dfs.pathTo(bfs_startstation, vertice)) pila_vuelta = (dfs.pathTo(bfs_backstation, vertice)) v1v = st.pop(pila_vuelta) v1 = st.pop(pila_ida) time += (20 * (st.size(pila_ida) + st.size(pila_vuelta))) while not st.isEmpty(pila_ida): v2 = st.pop(pila_ida) time += e.weight(gr.getEdge(analyzer['graph'], v1, v2)) v1 = v2 if time / 60 > avaibleTimemax: break while not st.isEmpty(pila_vuelta): v2v = st.pop(pila_vuelta) time += e.weight(gr.getEdge(analyzer['graph'], v1v, v2v)) v1v = v2v if time / 60 > avaibleTimemax: break time = round(time / 60, 2) if time >= avaibleTimemin and time <= avaibleTimemax: rutas += 1 StartStationName = getName(analyzer["stationinfo"], StartStationid) FinalStationName = getName(analyzer["stationinfo"], vertice) r["R_Especifico"][rutas] = { "Nombre_station_Inicio": StartStationName, "Nombre_station_Final": FinalStationName, "tiempo en min ": time } elif sameCC(analyzer, StartStationid, vertice) == None: pass return (totalrutas, rutas, r)
def Ruta_turistica_circular(graph, tiempo, estacion_inicio): Tiempo = float(tiempo) * 60 kosa = scc.KosarajuSCC(graph["graph"]) est_k_idscc = kosa["idscc"] dfs_recor = dfs.DepthFirstSearchsSCC(graph["graph"], estacion_inicio, est_k_idscc) Lista = m.keySet(dfs_recor["visited"]) iterador = it.newIterator(Lista) L2 = lt.newList() while it.hasNext(iterador): element = it.next(iterador) camino = None if dfs.hasPathTo(dfs_recor, element): vertices = gr.adjacents(graph["graph"], element) it2 = it.newIterator(vertices) while it.hasNext(it2): elemento2 = it.next(it2) if elemento2 == estacion_inicio: camino = dfs.pathTo(dfs_recor, element) if camino != None: lt.addLast(L2, camino) lista_rutas = lst = lt.newList("ARRAY_LIST") iterador2 = it.newIterator(L2) while it.hasNext(iterador2): elemento = it.next(iterador2) lst = [] while (not st.isEmpty(elemento)): stop = st.pop(elemento) lst.append(stop) lt.addLast(lista_rutas, lst) lista_final = lt.newList() iterador_fin = it.newIterator(lista_rutas) while it.hasNext(iterador_fin): lista_pe = it.next(iterador_fin) total = 0 total += (len(lista_pe) - 1) * 20 * 60 edge = gr.getEdge(graph["graph"], lista_pe[len(lista_pe) - 1], lista_pe[0]) peso = float(edge["weight"]) total += peso i = 0 while i < len(lista_pe): estacion = lista_pe[i] j = i + 1 while j != 0 and i < ((len(lista_pe)) - 1): estacion2 = lista_pe[j] edge2 = gr.getEdge(graph["graph"], estacion, estacion2) peso2 = float(edge2["weight"]) total += peso2 j = 0 i += 1 lista_parcial = [] ruta = {"Peso": round(total, 2), "ruta": None} if total <= Tiempo: i = 0 while i < len(lista_pe): estacion1 = lista_pe[i] entry = m.get(graph["Estaciones"], estacion1) valor = me.getValue(entry) nombre = valor["Nombre"] lista_parcial.append(nombre) i += 1 ruta["ruta"] = lista_parcial lt.addLast(lista_final, ruta) return lista_final