def dfs_2(grafo, v, revisados):
adjs = g.adjacents(grafo, v)
adjs_iter = it.newIterator(adjs)
while (it.hasNext(adjs_iter)):
w = it.next(adjs_iter)
visited_w = map.contains(revisados, w)
if visited_w == False:
map.put(revisados, w, {'marked': True, 'edgeTo': v})
dfs_2(grafo, w, revisados)
def depth_first_search(Graph, Mapa_de_marcar, node):
valor={'nodo':node, 'stado':True, 'predecesor':None}
map.put(Mapa_de_marcar,valor['nodo'],valor)
list_ad=g.adjacents(Graph,node)
for i in range (1,lt.size(list_ad)+1):
li_node=lt.getElement(list_ad,i)
if not map.contains(Mapa_de_marcar,li_node):
record={'nodo':li_node, 'stado':True, 'predecesor':node}
map.put(Mapa_de_marcar,record['nodo'],record)
depth_first_search(Graph, Mapa_de_marcar, li_node)
def depth_first_search(catalog,node):
valor={'nodo':node, 'stado':True, 'predecesor':None}
map.put(catalog['visitedMap'],valor['nodo'],valor)
list_ad=g.adjacents(catalog['delayGraph'],node)
for i in range (1,lt.size(list_ad)+1):
li_node=lt.getElement(list_ad,i)
if not map.contains(catalog['visitedMap'],li_node):
record={'nodo':li_node, 'stado':True, 'predecesor':node}
map.put(catalog['visitedMap'],record['nodo'],record)
depth_first_search(catalog,li_node)
def contar_conectados(grafo, dicc_vertices, vertice):
adjacentes = g.adjacents(grafo, vertice)
if adjacentes != None:
iterator2 = it.newIterator(adjacentes)
while it.hasNext(iterator2):
vertice_adj = it.next(iterator2)
esta_visitado = dicc_vertices.get(vertice_adj)
if esta_visitado != "visited":
dicc_vertices[vertice_adj] = "visited"
contar_conectados(grafo, dicc_vertices, vertice_adj)
return dicc_vertices
def dfs(self, graph, vert, marked, pre, post, reversepost):
q.enqueue(pre, vert)
m.put(marked, vert, True)
lstadjacents = g.adjacents(graph, vert)
adjiterator = it.newIterator(lstadjacents)
while it.hasNext(adjiterator):
adjvert = it.next(adjiterator)
if not m.contains(marked, adjvert):
self.dfs(graph, adjvert, marked, pre, post, reversepost)
q.enqueue(post, vert)
s.push(reversepost, vert)
def sccCount(self, graph, vert, marked, idscc, scc):
"""
Este algoritmo cuenta el número de componentes conectados.
Deja en idscc, el número del componente al que pertenece cada vértice
"""
m.put(marked, vert, True)
m.put(idscc, vert, scc)
lstadjacents = g.adjacents(graph, vert)
adjiterator = it.newIterator(lstadjacents)
while it.hasNext(adjiterator):
adjvert = it.next(adjiterator)
if not m.contains(marked, adjvert):
self.sccCount(graph, adjvert, marked, idscc, scc)
def test_adjacents(self):
graph = g.newGraph(7, self.comparenames, directed=True)
g.insertVertex(graph, 'Bogota')
g.insertVertex(graph, 'Yopal')
g.insertVertex(graph, 'Cali')
g.insertVertex(graph, 'Medellin')
g.insertVertex(graph, 'Pasto')
g.insertVertex(graph, 'Barranquilla')
g.insertVertex(graph, 'Manizales')
g.addEdge(graph, 'Bogota', 'Yopal')
g.addEdge(graph, 'Bogota', 'Medellin')
g.addEdge(graph, 'Bogota', 'Pasto')
g.addEdge(graph, 'Bogota', 'Cali')
g.addEdge(graph, 'Cali', 'Bogota')
g.addEdge(graph, 'Yopal', 'Medellin')
g.addEdge(graph, 'Medellin', 'Pasto')
g.addEdge(graph, 'Pasto', 'Bogota')
g.addEdge(graph, 'Cali', 'Pasto')
g.addEdge(graph, 'Cali', 'Barranquilla')
g.addEdge(graph, 'Barranquilla', 'Manizales')
g.addEdge(graph, 'Pasto', 'Manizales')
self.assertEqual(g.numEdges(graph), 12)
self.assertEqual(g.numVertex(graph), 7)
lst = g.adjacents(graph, 'Bogota')
self.assertEqual(lt.size(lst), 4)
self.assertTrue(lt.isPresent(lst, 'Cali', self.comparelst))
self.assertTrue(lt.isPresent(lst, 'Yopal', self.comparelst))
self.assertTrue(lt.isPresent(lst, 'Pasto', self.comparelst))
self.assertTrue(lt.isPresent(lst, 'Medellin', self.comparelst))
self.assertFalse(lt.isPresent(lst, 'Barranquilla', self.comparelst))
lst = g.adjacents(graph, 'Manizales')
self.assertEqual(lt.size(lst), 0)
def dfs(self, graph, vert, marked, pre, post, reversepost):
"""
Implementación del recorrido Depth First Search
"""
q.enqueue(pre, vert)
m.put(marked, vert, True)
lstadjacents = g.adjacents(graph, vert)
adjiterator = it.newIterator(lstadjacents)
while it.hasNext(adjiterator):
adjvert = it.next(adjiterator)
if not m.contains(marked, adjvert):
self.dfs(graph, adjvert, marked, pre, post, reversepost)
q.enqueue(post, vert)
s.push(reversepost, vert)
def bfs(search, source):
queue = q.newQueue()
q.enqueue(queue, source)
while not (q.isEmpty(queue)):
v = q.dequeue(queue)
list_ad = g.adjacents(search['graph'], v)
for i in range(1, (lt.size(list_ad) + 1)):
w = lt.getElement(list_ad, i)
if map.get(search['visitedMap'], w) == None:
map.put(search['visitedMap'], w, {
'marked': True,
'edgeTo': None,
'nodo': w
})
q.enqueue(queue, w)
def newDijkstra(graph, s):
"""
Crea una busqueda Dijkstra para un digrafo y un vertice origen
"""
prime = nextPrime(g.numVertex(graph) * 2)
search = {'graph': graph, 's': s, 'visitedMap': None, 'minpq': None}
search['visitedMap'] = map.newMap(capacity=prime,
maptype='PROBING',
comparefunction=graph['comparefunction'])
vertices = g.vertices(graph)
itvertices = it.newIterator(vertices)
while (it.hasNext(itvertices)):
vert = it.next(itvertices)
map.put(search['visitedMap'], vert, {
'marked': False,
'edgeTo': None,
'distTo': math.inf
})
map.put(search['visitedMap'], s, {
'marked': True,
'edgeTo': None,
'distTo': 0
})
pq = minpq.newIndexMinPQ(g.numVertex(graph), comparenames)
search['minpq'] = pq
minpq.insert(search['minpq'], s, 0)
while not minpq.isEmpty(search['minpq']):
v = minpq.delMin(pq)
if not g.containsVertex(graph, v):
raise Exception("Vertex [" + v + "] is not in the graph")
elif g.containsVertex(graph, v):
adj = g.adjacents(graph, v)
adj_it = it.newIterator(adj)
while it.hasNext(adj_it):
w = it.next(adj_it)
edge = g.getEdge(graph, v, w)
relax(search, edge)
# obtener los enlaces adjacentes de v
# Iterar sobre la lista de enlaces
# Relajar (relax) cada enlace
return search
def reverse(self, graph):
"""
Retornar el reverso del grafo graph
"""
greverse = g.newGraph(12, self.comparenames, directed=True)
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
def test_addEdges(self):
graph = g.newGraph(7, self.comparenames)
g.insertVertex(graph, 'Bogota')
g.insertVertex(graph, 'Yopal')
g.insertVertex(graph, 'Cali')
g.insertVertex(graph, 'Medellin')
g.insertVertex(graph, 'Pasto')
g.insertVertex(graph, 'Barranquilla')
g.insertVertex(graph, 'Manizales')
g.addEdge(graph, 'Bogota', 'Yopal')
g.addEdge(graph, 'Bogota', 'Medellin')
g.addEdge(graph, 'Bogota', 'Pasto')
g.addEdge(graph, 'Bogota', 'Cali')
g.addEdge(graph, 'Yopal', 'Medellin')
g.addEdge(graph, 'Medellin', 'Pasto')
g.addEdge(graph, 'Cali', 'Pasto')
g.addEdge(graph, 'Cali', 'Barranquilla')
g.addEdge(graph, 'Barranquilla', 'Manizales')
g.addEdge(graph, 'Pasto', 'Manizales')
self.assertEqual(g.numEdges(graph), 10)
self.assertEqual(g.numVertex(graph), 7)
lst = g.vertices(graph)
self.assertEqual(lt.size(lst), 7)
lst = g.edges(graph)
self.assertEqual(lt.size(lst), 10)
degree = g.degree(graph, 'Bogota')
self.assertEqual(degree, 4)
edge = g.getEdge(graph, 'Bogota', 'Medellin')
lst = g.adjacents(graph, 'Bogota')
self.assertEqual(lt.size(lst), 4)
def test_adjacents(self):
graph = g.newGraph(7,self.comparenames)
g.insertVertex (graph, 'Bogota')
g.insertVertex (graph, 'Yopal')
g.insertVertex (graph, 'Cali')
g.insertVertex (graph, 'Medellin')
g.insertVertex (graph, 'Pasto')
g.insertVertex (graph, 'Barranquilla')
g.insertVertex (graph, 'Manizales')
g.addEdge (graph, 'Bogota', 'Yopal')
g.addEdge (graph, 'Bogota', 'Medellin')
g.addEdge (graph, 'Bogota', 'Pasto')
g.addEdge (graph, 'Bogota', 'Cali')
g.addEdge (graph, 'Yopal', 'Medellin')
g.addEdge (graph, 'Medellin', 'Pasto')
g.addEdge (graph, 'Cali', 'Pasto')
g.addEdge (graph, 'Cali', 'Barranquilla')
g.addEdge (graph, 'Barranquilla','Manizales')
g.addEdge (graph, 'Pasto','Manizales')
lst=g.adjacents(graph,'Bogota')
self.assertEqual(lt.size(lst),4)
