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
