def dfsVertex(graph, search, vertex):
"""
Genera un recorrido DFS sobre el grafo graph
Args:
graph: El grafo a recorrer
source: Vertice de inicio del recorrido.
Returns:
Una estructura para determinar los vertices
conectados a source
Raises:
Exception
"""
try:
queue.enqueue(search['pre'], vertex)
map.put(search['marked'], vertex, True)
lstadjacents = g.adjacents(graph, vertex)
adjiterator = it.newIterator(lstadjacents)
while it.hasNext(adjiterator):
adjvert = it.next(adjiterator)
if not map.contains(search['marked'], adjvert):
dfsVertex(graph,
search,
adjvert,
)
queue.enqueue(search['post'], vertex)
stack.push(search['reversepost'], vertex)
return search
except Exception as exp:
error.reraise(exp, 'dfo:dfsVertex')
def bfsVertex(search, graph, source):
"""
Funcion auxiliar para calcular un recorrido BFS
Args:
search: Estructura para almacenar el recorrido
vertex: Vertice de inicio del recorrido.
Returns:
Una estructura para determinar los vertices
conectados a source
Raises:
Exception
"""
try:
adjsqueue = queue.newQueue()
queue.enqueue(adjsqueue, source)
while not (queue.isEmpty(adjsqueue)):
vertex = queue.dequeue(adjsqueue)
visited_v = map.get(search['visited'], vertex)['value']
adjslst = g.adjacents(graph, vertex)
adjslstiter = it.newIterator(adjslst)
while (it.hasNext(adjslstiter)):
w = it.next(adjslstiter)
visited_w = map.get(search['visited'], w)
if visited_w is None:
dist_to_w = visited_v['distTo'] + 1
visited_w = {
'marked': True,
'edgeTo': vertex,
"distTo": dist_to_w
}
map.put(search['visited'], w, visited_w)
queue.enqueue(adjsqueue, w)
return search
except Exception as exp:
error.reraise(exp, 'bfs:bfsVertex')
def affectedCountries(catalog, point):
# Mapa para que no se repitan los países que se guardan
mapa_paises = mp.newMap(numelements=13, maptype="PROBING", loadfactor=0.4)
lista_vertices_point = mp.keySet(
mp.get(mp.get(catalog["points"], point)["value"],
"mapa_vertices")["value"])
for vertice_point in lt.iterator(lista_vertices_point):
vertices_adyacentes = gr.adjacents(catalog["connections"],
vertice_point)
for adyacente in lt.iterator(vertices_adyacentes):
point_adyacente = getLandingPoint(adyacente)
pais_adyacente = mp.get(
mp.get(catalog["points"], point_adyacente)["value"],
"country")["value"]
mp.put(mapa_paises, pais_adyacente, None)
tamaño = mp.size(mapa_paises)
lista_paises = mp.keySet(mapa_paises)
return tamaño, lista_paises
########################################### 5 #################################################
def reverseGraph(graph):
"""
Retornar el reverso del grafo graph
"""
try:
greverse = g.newGraph(size=g.numVertices(graph),
directed=True,
comparefunction=graph['comparefunction'])
lstvert = g.vertices(graph)
itervert = it.newIterator(lstvert)
while it.hasNext(itervert):
vert = it.next(itervert)
g.insertVertex(greverse, vert)
itervert = it.newIterator(lstvert)
while it.hasNext(itervert):
vert = it.next(itervert)
lstadj = g.adjacents(graph, vert)
iteradj = it.newIterator(lstadj)
while it.hasNext(iteradj):
adj = it.next(iteradj)
g.addEdge(greverse, adj, vert)
return greverse
except Exception as exp:
error.reraise(exp, 'scc:reverse')
def getAdjacentVertexs(analyzer, vertex):
"""
Retorna una lista con los vértices adyacentes a
un vértice específico
"""
graph = analyzer['connections']
lstadjacents = gr.adjacents(graph, vertex)
return lstadjacents
def bfsVertex(search, graph, source, maxtime):
"""
Funcion auxiliar para calcular un recorrido BFS
Args:
search: Estructura para almacenar el recorrido
vertex: Vertice de inicio del recorrido.
Returns:
Una estructura para determinar los vertices
conectados a source
Raises:
Exception
"""
try:
adjsqueue = queue.newQueue()
queue.enqueue(adjsqueue, source)
while not queue.isEmpty(adjsqueue):
vertex = queue.dequeue(adjsqueue)
visited_v = map.get(search['visited'], vertex)['value']
adjslst = g.adjacents(graph, vertex)
adjslstiter = it.newIterator(adjslst)
if not (it.hasNext(adjslstiter)):
visited_v["final"] = True
c = 0
while (it.hasNext(adjslstiter)):
if c == 1 and vertex != source:
break
total_time = 0
w = it.next(adjslstiter)
if not (it.hasNext(adjslstiter)) and c == 0:
visited_v["final"] = True
edge = g.getEdge(graph, vertex, w)
time = edge['weight'] / 60
visited_w = map.get(search['visited'], w)
if visited_w is None:
if visited_v["final"] == False:
dist_to_w = visited_v['distTo'] + time
total_time = dist_to_w
if total_time <= maxtime:
visited_w = {
'marked': True,
'edgeTo': vertex,
"distTo": dist_to_w,
"final": False
}
map.put(search['visited'], w, visited_w)
queue.enqueue(adjsqueue, w)
c = 1
return search
except Exception as exp:
error.reraise(exp, 'bfs:bfsVertex')
def failImpact(analyzer, landingPoint):
# Se obtiene el id del landing point a partir de su nombre
vertexId = me.getValue(mp.get(analyzer['landingPointNames'], landingPoint))
# Se obtiene la entrada del mapa para el landing point
lp = me.getValue(mp.get(analyzer['landingPoints'], vertexId))
# Se obtiene el nombre del país del landing point que falla
countryName = lp['country']
# Se obtienen los datos del país del landing point que falla
country = me.getValue(mp.get(analyzer['countries'], countryName))
# Se crea un mapa para almacenar los nombres de los países que estan conectados al landing point que falla
countries = mp.newMap(numelements=300, maptype='PROBING')
# Se obtienen los vértices adyacentes para cada uno de los vertices del landing point
for vertex in lt.iterator(lp['vertices']):
# Los vertices adyacentes se almacenan en una lista
adjVertices = gr.adjacents(analyzer['connections'], vertex)
# Para cada vertice adyacente, se obtiene el país
for adjVertex in lt.iterator(adjVertices):
# Si el vertice adyacente corresponde al vertice de la ciudad capital, se intenta agregar el país actual
if adjVertex == country['vertex']:
# Se verifica que el país no exista en el listado de resultado
if not mp.contains(countries, countryName):
# Se obtiene el arco para poder saber la distancia y se agrega el pais al listado de resultado
ctryEdge = gr.getEdge(analyzer['connections'], vertex,
country['vertex'])
mp.put(countries, countryName, ctryEdge['weight'])
else:
# Si el vertice no corresponde a un vertice de capital, se obtiene su id y luego su entrada en el mapa de landing points
adjVertexId = adjVertex.split('-')[0]
adjLP = me.getValue(
mp.get(analyzer['landingPoints'], adjVertexId))
# Se verifica si el país del landing point adyacente ya existe en el listado, y si no, se agrega
if not mp.contains(countries, adjLP['country']):
adjEdge = gr.getEdge(analyzer['connections'], vertex,
adjVertex)
mp.put(countries, adjLP['country'], adjEdge['weight'])
countriesList = mp.keySet(countries)
# Se crea un mapa ordenado para el resultado
result = om.newMap('BST')
for ctry in lt.iterator(countriesList):
distance = me.getValue(mp.get(countries, ctry))
if om.contains(result, distance):
ctryList = me.getValue(om.get(result, distance))
lt.addLast(ctryList, ctry)
else:
newList = lt.newList('SINGLE_LINKED', compareCountries)
lt.addLast(newList, ctry)
om.put(result, distance, newList)
return mp.size(countries), result
def mostConnectedLandingPoint(analyzer):
"""
Retorna un árbol tipo 'RBT' con los puntos de conexión
con mayor número de conexiones
"""
graph = analyzer['connections']
map = analyzer['vertexscoords']
ordmap = om.newMap('RBT', compareValuesDescOrder)
lstvertexs = mp.keySet(map)
for vertex in lt.iterator(lstvertexs):
lstconnections = gr.adjacents(graph, vertex)
connections = lt.size(lstconnections)
om.put(ordmap, connections, vertex)
return ordmap
def getAffectedCountries(catalog, landingpoint):
lp = me.getValue(mp.get(catalog['landing_points'], landingpoint))
affectedcountries = lt.newList('ARRAY_LIST')
for cable in lt.iterator(lp['cables']):
#O(N) donde N es la cantidad de cables que se conectan con ese landing point
vertexname = landingpoint + "-" + cable['cable_name']
affectedvertices = gr.adjacents(catalog['connections'], vertexname)
for vertex in lt.iterator(affectedvertices):
#O(M) donde M es la la cantidad de vertices adyacentes al nodo específico
vertexcountry = me.getValue(
mp.get(catalog['landing_points'],
vertex.split("-")[0]))['info']["name"].split(", ")[-1]
if not lt.isPresent(affectedcountries, vertexcountry):
lt.addLast(affectedcountries, vertexcountry)
return affectedcountries
def sccCount(graph, scc, vert):
"""
Este algoritmo cuenta el número de componentes conectados.
Deja en idscc, el número del componente al que pertenece cada vértice
"""
try:
map.put(scc['marked'], vert, True)
map.put(scc['idscc'], vert, scc['components'])
lstadjacents = g.adjacents(graph, vert)
for adjvert in lt.iterator(lstadjacents):
if not map.contains(scc['marked'], adjvert):
sccCount(graph, scc, adjvert)
return scc
except Exception as exp:
error.reraise(exp, 'dfo:sccCount')
def req5(catalog, nombre_landing_point):
grafo = catalog['graph_landing_points']
#paises = mp.keySet(catalog['map_countries'])
lista_vertices = gr.vertices(catalog['graph_landing_points'])
lista_ciudades_afectadas = lt.newList(datastructure='ARRAY_LIST')
tabla_landing_points = catalog['map_landing_points']
#llaves_landing_points = mp.keySet(tabla_landing_points)
lista_numvertice = lt.newList(datastructure='ARRAY_LIST')
lista_paises_afectados = lt.newList(datastructure='ARRAY_LIST')
lista_tablas = lt.newList(datastructure='ARRAY_LIST')
vertice = None
for vert in lt.iterator(lista_vertices):
if nombre_landing_point == vert.split(sep='*')[1]:
vertice = vert
paises_afectados = gr.adjacents(grafo, vertice)
for vertices in lt.iterator(paises_afectados):
if (int(
lt.isPresent(lista_ciudades_afectadas,
vertices.split(sep='*')[1]))) == 0:
lt.addLast(lista_ciudades_afectadas,
vertices.split(sep='*')[1])
lt.addLast(lista_numvertice, vertices.split(sep='*')[0])
for numvertices in lt.iterator(lista_numvertice):
entry1 = mp.get(tabla_landing_points, numvertices)
tabla1 = me.getValue(entry1)
valores = mp.valueSet(tabla1)
values_iterator = it.newIterator(valores)
elemento = it.next(values_iterator)
ciudades_elemento = elemento['name'].split(sep=',')
for ciudades in lt.iterator(lista_ciudades_afectadas):
if ciudades in ciudades_elemento:
pais = ciudades_elemento[-1]
if (int(
lt.isPresent(lista_paises_afectados,
pais))) == 0:
lt.addLast(lista_paises_afectados, pais)
return lt.size(lista_paises_afectados), lista_paises_afectados['elements']
def Requerimiento5(analyzer, landing_point_name):
map_respuesta = mp.newMap()
#encontrar codigo con nombre
mapa_codigo = analyzer['landing_names_id']
pareja_codigo = mp.get(mapa_codigo, landing_point_name)
codigo = me.getValue(pareja_codigo)
#sacar vertices de este landing point (unicamente estara conectado a un vertice de pais y es el vertice de su mismo pais)
mapa_vertices = analyzer['landing_points']
pareja_vertices = om.get(mapa_vertices, codigo)
dict_landing = me.getValue(pareja_vertices)
lista_vertices = dict_landing['cables']
for i in range(lt.size(lista_vertices)):
vertice = lt.getElement(lista_vertices, i)
arcos_vertice = gr.adjacents(analyzer['connections'], vertice)
for i in range(lt.size(arcos_vertice)):
vertice2 = lt.getElement(arcos_vertice, i)
tuple_vertice2 = vertice2.replace('<', '').replace('>',
'').split('-')
origen = tuple_vertice2[0]
contains_landing = om.contains(analyzer['landing_points'], origen)
if contains_landing:
#extraer pais del origen
pareja_origen = om.get(analyzer['landing_points'], origen)
dict_origen = me.getValue(pareja_origen)
pais = dict_origen['country']
contains_country = mp.contains(map_respuesta, pais)
if not contains_country:
mp.put(map_respuesta, pais, 0)
print(mp.keySet(map_respuesta))
from DISClib.ADT import graph as gr
from DISClib.ADT import list as lt
# Creacion de un grafo no dirigido
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)
gr.insertVertex(grafo, "1")
gr.insertVertex(grafo, "2")
gr.addEdge(grafo, "1", "2")
#Imprimir el grafo
for v in lt.iterator(gr.vertices(grafo)):
print(v)
adj = gr.adjacents(grafo, v)
for a in lt.iterator(adj):
print('-', a)
print()
