class Directed_DFS_Orderings:
def __init__(self, digraph):
self.marked_array = [False] * digraph.V()
self.pre_order = Queue_LinkedList()
self.post_order = Queue_LinkedList()
self.reverse_post_order = Stack_ResizingArray()
for i in range(digraph.V()):
if not self.marked_array[i]:
self.dfs(i, digraph)
def dfs(self, v, digraph):
self.pre_order.enqueue(v)
self.marked_array[v] = True
for j in digraph.adjacent(v):
if not self.marked_array[j]:
self.dfs(j, digraph)
self.post_order.enqueue(v)
self.reverse_post_order.push(v)
def preorder(self):
return self.pre_order
def postorder(self):
return self.post_order
def reversepostorder(self):
return self.reverse_post_order
class Directed_DFS_Orderings_EWD:
def __init__(self, ew_digraph):
self.ew_digraph = ew_digraph
self.marked_array = [False] * self.ew_digraph.V()
self.pre_order = Queue_LinkedList()
self.post_order = Queue_LinkedList()
self.reverse_post_order = Stack_ResizingArray()
for i in range(self.ew_digraph.V()):
if self.marked_array[i] != True:
self.dfs(i)
def dfs(self, v):
self.pre_order.enqueue(v)
self.marked_array[v] = True
# For Edge_Weighted_Digraph, self.ew_digraph.adjacent(v) returns the edges coming from vertex v (in Digraph, self.digraph.adjacent(v) returns the vertices v is pointing towards).
for directed_edge in self.ew_digraph.adjacent(v):
w = directed_edge.towards_vert()
if self.marked_array[w] != True:
self.dfs(w)
self.post_order.enqueue(v)
self.reverse_post_order.push(v)
def preorder(self):
return self.pre_order
def postorder(self):
return self.post_order
def reversepostorder(self):
return self.reverse_post_order
def pathTo(self, v):
if not self.hasPathTo(v): return None
stack = Stack_ResizingArray()
while v is not None:
stack.push(v)
v = self.paths_array[v]
return stack
def pathTo(self, v):
if not self.hasPathTo(v): return None
stack = Stack_ResizingArray()
x = v
while x is not None:
stack.push(x)
x = self.path_array[x]
return stack
def pathTo(self,v):
path_stack = Stack_ResizingArray()
directed_edge = self.edgeTo[v]
if v == self.s:
return "No edges required to reach source vertex from source vertex"
vert_from = directed_edge.from_vert()
while vert_from != self.s:
path_stack.push(directed_edge)
directed_edge = self.edgeTo[vert_from]
vert_from = directed_edge.from_vert()
path_stack.push(directed_edge)
return path_stack
def dfs(self, graph, s):
stack = Stack_ResizingArray()
stack.push(s)
while stack:
v = stack.pop()
self.count_connected += 1
print(v, self.count_connected)
for neighbor in graph.adj[v]:
if not self.marked_array[neighbor]:
self.marked_array[v] = True
stack.push(neighbor)
def dfs(self, graph, v):
self.marked_array[v] = True
stack = Stack_ResizingArray()
stack.push(v)
while stack:
vertex = stack.pop()
neighbors_list = graph.adj[vertex]
for i in neighbors_list:
if self.marked_array[i] != True:
stack.push(i)
self.marked_array[vertex] = True
self.path_array[i] = vertex
class Directed_Weighted_Cycle:
def __init__(self, ew_digraph):
# This is used to keep track of whether a vertex has been encountered or not.
# This way dfs() will only run at most once for each vertex
self.marked_array = [False] * ew_digraph.V()
# This array is used to build the cycle_stack
# For a given index
self.edgeTo = [None] * ew_digraph.V()
# This stack stays empty until a cycle is detected.
# If a cycle is detected, all of the vertices along the cycle are added to the stack
# This is done by utilizing the paths_array which stores the previous vertex along its path
self.cycle_stack = Stack_ResizingArray()
# This array keeps track of whether a vertex is still on the call stack.
# If we encounter a vertex that is still on the call stack, then we know a cycle exists (similar to how if the end of the string re-encounters the string in the Tremaux maze)
# The value at a given index is turned to True while it is on the call stack and turned to False when dfs finishes (and it is no longer on the call stack)
self.onStack = [False] * ew_digraph.V()
for i in range(ew_digraph.V()):
# This way dfs goes through all vertices even if in different components.
if self.marked_array[i] != True:
self.dfs(i, ew_digraph)
def dfs(self, v, ew_digraph):
self.onStack[v] = True
self.marked_array[v] = True
# For Edge_Weighted_Digraph, self.ewdigraph.adjacent(v) returns the edges coming from vertex v (in Digraph, self.digraph.adjacent(v) returns the vertices v is pointing towards.
for directed_edge in ew_digraph.adjacent(v):
w = directed_edge.towards_vert()
# 1.
# If a cycle has already been detected (and consequently cycle_stack has been built),
# Then no more calls to dfs() will be added to the call stack and those remaining are quickly finished w/ this return statement.
if self.hasCycle() == True:
return
# 2.
# If a vertex has already been encountered, then we don't need to re-search through its neighbors.
# We only search through the neighbors of a vertex once.
elif self.marked_array[w] == False:
self.edgeTo[w] = directed_edge
self.dfs(w, ew_digraph)
# 3.
# If this is a true, a cycle has been detected and we can build the cycle stack to show the cycle.
elif self.onStack[w] == True:
self.cycle_stack.push(directed_edge)
x = self.edgeTo[v]
while x.from_vert() != directed_edge.towards_vert():
self.cycle_stack.push(x)
x = self.edgeTo[x.from_vert()]
self.cycle_stack.push(x)
self.onStack[v] = False
def hasCycle(self):
return not self.cycle_stack.isEmpty()
def cycle(self):
if self.hasCycle() == False:
return None
else:
return self.cycle_stack