def recorrido_anchura(grafo: "Graph<T>", v_inicial: "T",
inversa: "bool") -> "List<(T,T)>":
aristas = []
queue = Fifo()
seen = set()
queue.push((v_inicial, v_inicial))
seen.add(v_inicial)
matriz[0][0] = 0
mInversa[0][0] = 0
while len(queue) > 0:
u, v = queue.pop()
aristas.append((u, v))
if (inversa):
peso = mInversa[v[0]][v[1]]
else:
peso = matriz[v[0]][v[1]]
for suc in grafo.succs(v):
if suc not in seen:
if (inversa):
mInversa[suc[0]][suc[1]] = peso + 1
seen.add(suc)
queue.push((v, suc))
else:
matriz[suc[0]][suc[1]] = peso + 1
seen.add(suc)
queue.push((v, suc))
return aristas
def kruskal_final(g, v_ini, aristas):
q = Fifo()
seen = set()
vertices = []
# q.push(v_ini)
seen.add(v_ini)
vertices.append(v_ini)
# sucs = g.succs(v_ini)
#
# vecino1 = sucs.pop()
# vecino2 = sucs.pop()
vecino1 = min(g.succs(v_ini))
# if aristas[(v_ini, vecino1)] < aristas[(v_ini, vecino2)]:
# vecino1 = vecino2
q.push(vecino1)
seen.add(vecino1)
while len(vertices) != len(g.V):
v = q.pop()
vertices.append(v)
for suc in g.succs(v):
if suc not in seen:
seen.add(suc)
q.push(suc)
return vertices
def BFS_wallbraker(g: UndirectedGraph, source: Vertex,
distances: dict) -> Edge:
seen = set()
min = float('infinity')
wall = ((-1, -1), (-1, -1))
queue = Fifo()
queue.push((source, 0))
seen.add(source)
while len(queue) > 0:
vertex, n = queue.pop()
u, v = vertex
# Comprobacion de vecinos tras los muros
for x, y in [(1, 0), (0, 1), (-1, 0), (0, -1)]:
neigh = (u + x, v + y)
if neigh not in g.succs((u, v)) and neigh in distances:
tdistance = n + distances[neigh]
if tdistance < min:
min = tdistance
wall = ((u, v), neigh)
for suc in g.succs(vertex):
if suc not in seen:
seen.add(suc)
queue.push((suc, n + 1))
return wall
def matriz_saltos(grafo, num_rows, num_cols):
m = []
#Generar una matriz
for r in range(num_rows):
m.append([0] * num_cols)
#deep_copy para copiar matrices o con un for
#TODO
#copiar el codigo del recorredor de aristas en anchura y
# modificarlo para rellenar a la vez matriz m
aristas = []
queue = Fifo()
seen = set()
queue.push((0, 0))
seen.add((0, 0))
while len(queue) > 0:
u, v = queue.pop()
aristas.append((u, v))
for suc in grafo.succs(v):
if suc not in seen:
seen.add(suc)
queue.push((v, suc))
return m
def recorredor_anchura(g: UndirectedGraph, source: "T", r: int, c: int):
#Crear e inicializar matriz
distances = []
for row in range(r):
distances.append([0] * c)
queue = Fifo()
seen = set()
#Añadir el punto inicial a la cola
queue.push((source, source))
seen.add(source)
while len(queue) > 0:
u, v = queue.pop()
#Miramos los sucesores del elemento extraido de la cola
for s in g.succs(v):
#Si no lo hemos visitado ya lo añadimos a los visitados y anotamos en la matriz su distancia al origen
if s not in seen:
seen.add(s)
distances[s[0]][s[1]] = distances[v[0]][
v[1]] + 1 #En la posición del sucesor el antecesor mas 1
queue.push((v, s))
return distances
class TestFifo(unittest.TestCase):
def setUp(self):
self.a = Fifo()
self.b = Fifo([1, 2, 3])
self.c = Fifo(createList=list)
self.d = Fifo([1, 2, 3], createList=list)
def test_ctor(self):
self.assertEqual(len(self.a), 0)
self.assertEqual(len(self.b), 3)
self.assertEqual(len(self.c), 0)
self.assertEqual(len(self.d), 3)
def test_push(self):
self.a.push(1)
self.assertEqual(len(self.a), 1)
self.a.push(2)
self.assertEqual(len(self.a), 2)
v = self.a.pop()
self.assertEqual(v, 1)
self.b.push(1)
self.assertEqual(len(self.b), 4)
self.c.push(1)
self.assertEqual(len(self.c), 1)
self.d.push(1)
self.assertEqual(len(self.d), 4)
def test_pop(self):
self.assertRaises(IndexError, self.a.pop)
i = 1
while len(self.b) > 0:
v = self.b.pop()
self.assertEqual(v, i)
i += 1
self.assertRaises(IndexError, self.c.pop)
i = 1
while len(self.d) > 0:
v = self.d.pop()
self.assertEqual(v, i)
i += 1
def test_top(self):
self.assertRaises(IndexError, self.a.top)
self.assertEqual(self.b.top(), 1)
def test_repr(self):
self.assertEqual(list(self.b), list(eval(repr(self.b))))
def BFS(g, source):
queue = Fifo()
seen = set()
queue.push((source, source))
edges = []
while len(queue) > 0:
u, v = queue.pop()
edges.append((u, v))
seen.add(v)
for suc in g.succs(v):
if suc not in seen:
queue.push((v, suc))
return edges
def recorredor_aristas_anchura(g: UndirectedGraph, v_inicial: Vertex) -> List[Edge]:
aristas = []
queue = Fifo()
seen = set()
queue.push((v_inicial, v_inicial))
seen.add(v_inicial)
while len(queue) > 0:
u, v = queue.pop()
aristas.append((u, v))
for suc in g.succs(v):
if suc not in seen:
seen.add(suc)
queue.push((v, suc))
return aristas
def busca_tesoro_primero_anchura (laberinto,v_inicio):
seen=set()
queue=Fifo()
queue.push(v_inicio)
seen.add(v_inicio)
while len(queue)>0:
v=queue.pop()
if v==v_tesoro:
return v
for succ in laberinto.succs(v):
if succ not in seen:
seen.add(succ)
queue.push(succ)
return None
def recorredor_aristas_anchura(grafo,v_inicial):
aredges]
seen=set()
queue=Fifo()
seen.add(v_inicial)
queue.push((v_inicial,v_inicial))
while len(queue)>0:
u,v=queue.pop()
aredgesppend((u,v))
for succ in grafo.succs(v):
if succ not in seen:
seen.add(succ)
queue.push((v,succ))
return aredges
def recorredor_vertices_anchura(grafo: "Graph<T>", v_inicial: "T") -> "List<T>":
vertices = []
queue =Fifo()
seen = set()
queue.push(v_inicial)
seen.add(v_inicial)
while len(queue)>0:
v = queue.pop()
vertices.append(v)
for suc in grafo.succs(v):
if suc not in seen:
seen.add(suc)
queue.push(suc)
return vertices
def min_distances(g: UndirectedGraph, ini: Vertex) -> Dict:
distances = {}
queue = Fifo()
seen = set()
queue.push((ini, ini, 0))
seen.add(ini)
while len(queue) > 0:
u, v, n, = queue.pop()
distances[v] = n
for suc in g.succs(v):
if suc not in seen:
seen.add(suc)
queue.push((v, suc, n + 1))
return distances
def travel_vertex_width(grafo, v_inicial):
edges = []
queue = Fifo()
seen = set()
queue.push(v_inicial)
seen.add(v_inicial)
while len(queue) > 0:
v = queue.pop()
edges.append(v)
for suc in grafo.succs(v):
if suc not in seen:
seen.add(suc)
queue.push(suc)
return edges
def shortest_path(g: UndirectedGraph, source: Vertex, target: Vertex):
aristas = []
queue = Fifo()
seen = set()
queue.push((source, source))
seen.add(source)
while len(queue) > 0:
u, v = queue.pop()
aristas.append((u, v))
for suc in g.succs():
if suc not in seen:
seen.add(suc)
queue.push((v, suc))
return recover_path(aristas, target)
def BFS_modified(g, source):
n = int(sqrt(len(g.V)))
matrix = [[0] * n for i in range(n)]
queue = Fifo()
seen = set()
queue.push((source, 0))
while len(queue) > 0:
(x,y), level = queue.pop()
matrix[x][y] = level
seen.add((x,y))
for suc in g.succs((x, y)):
if suc not in seen:
queue.push((suc, level + 1))
return matrix
def anchura(g: UndirectedGraph, source: tuple) -> list:
visitados = set()
aristas = []
queue = Fifo()
queue.push((source, source))
visitados.add(source)
while len(queue) > 0:
u, v = queue.pop()
for suc in g.succs(v):
if suc not in visitados:
visitados.add(suc)
aristas.append((v, suc))
queue.push((v, suc))
return aristas
def traveler_edges_width(graph, v_initial):
edges = []
queue = Fifo()
seen = set()
queue.push((v_initial, v_initial))
seen.add(v_initial)
while len(queue) > 0:
u, v = queue.pop()
edges.append((u, v))
for suc in graph.succs(v):
if suc not in seen:
seen.add(suc)
queue.push((v, suc))
return edges
def recorre_aristas_anchura(grafo: Digraph, v_inical: Vertex) -> List[Edge]:
aristas = []
seen = set()
queue = Fifo()
queue.push((v_inical, v_inical))
seen.add(v_inical)
while len(queue) > 0:
u, v = queue.pop()
aristas.append((u, v))
for suc in grafo.succs():
if suc not in seen:
seen.add(suc)
queue.push((u, v))
return aristas
def recorredor_vertices_anchura(lab, v_inicial):
vertices = []
queue = Fifo()
seen = set()
queue.push(v_inicial)
seen.add(v_inicial)
while len(queue) > 0:
v = queue.pop()
vertices.append(v)
for suc in lab.succs(v):
if suc not in seen:
seen.add(suc)
queue.push(suc)
return vertices
def edges_withd_path(graph: "UndirectedGraph", initial_v: Tuple[int, int],
ma):
queue = Fifo()
seen = set()
queue.push((initial_v, initial_v))
seen.add(initial_v)
ma[initial_v[0]][initial_v[1]] = -1
while len(queue) > 0:
u, v = queue.pop()
ma[v[0]][v[1]] = ma[u[0]][u[1]] + 1
for suc in graph.succs(v):
if suc not in seen:
seen.add(suc)
queue.push((v, suc))
return ma
def recorredor_aristas_anchura(grafo: "Graph<T>",
v_inicial: "T") -> "List<(T,T)>":
aristas = []
queue = Fifo()
seen = set()
queue.push((v_inicial, v_inicial))
seen.add(v_inicial)
while len(queue) > 0:
u, v = queue.pop()
aristas.append((u, v))
for suc in grafo.succs(v):
if suc not in seen:
seen.add(suc)
queue.push((v, suc))
return aristas
def recorredor_aristas_anchura(g, source):
aristas = []
seen = set()
queue = Fifo()
seen.add(source)
queue.push((source, source))
while len(queue) > 0:
u, v = queue.pop()
aristas.append((u, v))
if v != target:
for succ in g.succs(v):
if succ not in seen:
seen.add(succ)
queue.push((v, succ))
return aristas
def mod_anchura(g: UndirectedGraph, source: tuple) -> list:
visitados = set()
n = int(sqrt(len(g.V)))
matriz = [[0] * n for i in range(n)]
queue = Fifo()
queue.push((source, 0))
visitados.add(source)
while len(queue) > 0:
u, n = queue.pop()
for sucx, sucy in g.succs(u):
if (sucx, sucy) not in visitados:
visitados.add((sucx, sucy))
matriz[sucx][sucy] = n + 1
queue.push(((sucx, sucy), n + 1))
return matriz
def recorredor_aristas_anchura(lab, v_inicial):
aristas = []
queue = Fifo()
seen = set()
queue.push((v_inicial, v_inicial))
seen.add(v_inicial)
while len(queue) > 0:
u, v = queue.pop()
aristas.append((u, v))
for suc in lab.succs(v):
if suc not in seen:
seen.add(suc)
queue.push((v, suc))
return aristas
def shortest_path(grafo: UndirectedGraph, source: Vertex,
target: Vertex) -> List[Edge]:
# sys.setrecursionlimit(10000) # en el caso de que el laberinto sea más grande, por lo tanto, la recursión más larga
edges = []
queue = Fifo()
seen = set()
queue.push((source, source))
seen.add(source)
while len(queue) > 0:
u, v = queue.pop()
edges.append((u, v))
for suc in grafo.succs(v):
if suc not in seen:
seen.add(suc)
queue.push((v, suc))
return recover_path(edges, target)
def BFS(g: UndirectedGraph, source: Vertex, target: Vertex) -> List[Edge]:
seen = set()
edges = []
queue = Fifo()
edges.append((source, source))
queue.push((source, source))
seen.add(source)
while len(queue) > 0:
u, v = queue.pop()
edges.append((u, v))
if (u, v) == target:
return edges
for suc in g.succs(v):
if suc not in seen:
seen.add(suc)
queue.push((v, suc))
return edges
def marca_pasos_desde(g: "UndirectedGraph<T>", v_entrada: "T") -> "Dictionary[Cells]->Int":
CuentaPasos = {}
CuentaPasos[v_entrada]=0
#Seguimos el modelo de recorre_vertices_anchura
queue = Fifo()
seen = set()
queue.push(v_entrada)
seen.add(v_entrada)
while len(queue)>0:
v=queue.pop()
for suc in g.succs(v):
if suc not in seen:
queue.push(suc)
seen.add(suc)
#Los pasos de esa casilla son uno más que los de su padre
CuentaPasos[suc]=CuentaPasos[v]+1
return CuentaPasos
def width_edges(g, source,
matrix): #Recorre aristas y actualiza matriz de costes
edges = []
seen = set()
queue = Fifo()
seen.add(source)
queue.push((source, source))
matrix[source[0]][source[1]] = 0
while len(queue) > 0:
u, v = queue.pop()
edges.append((u, v))
for succ in g.succs(v):
if succ not in seen:
matrix[succ[0]][succ[1]] = matrix[v[0]][v[1]] + 1
seen.add(succ)
queue.push((v, succ))
return (edges, matrix)
def jump_matrix(grafo, num_rows: int, num_cols: int, v_inicial):
m = []
for r in range(num_rows):
m.append([0] * num_cols)
vertices = []
queue = Fifo()
seen = set()
queue.push(v_inicial)
seen.add(v_inicial)
while len(queue) > 0:
v = queue.pop()
vertices.append(v)
for suc in grafo.succs(v):
if suc not in seen:
seen.add(suc)
m[suc[0]][suc[1]] = m[v[0]][v[1]] + 1
queue.push(suc)
return m
def bfst(lab, v_ini, v_tes):
q = Fifo()
seen = set()
q.push(v_ini)
seen.add(v_ini)
while len(q) > 0:
at = q.pop()
if v_tes == at:
return at
for suc in lab.succs(at):
if suc not in seen:
seen.add(suc)
q.push(suc)
return None
