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()