def as_EL(self):
g = el.Graph(len(self.am), self.weighted, self.directed)
for i in range(len(self.am)):
for j in range(len(self.am[i])):
g.insert_edge(i,j,self.am[i][j])
return g
def as_EL(self):
g = el.Graph(len(self.al), self.weighted, self.directed)
for i in range(len(self.al)):
for edge in self.al[i]:
g.insert_edge(i, edge.dest, edge.weight)
#print(g.representation)
return g
def as_EL(self):
temp = gEL.Graph(16, directed=False)
for x in range(len(self.am)):
for y in range(len(self.am[x])):
if self.am[x][y] != -1:
temp.insert_edge(x, y)
return temp
def as_EL(self):
edge_list = EL.Graph(
len(self.al), self.weighted,
self.directed) # makes a EL graph that is same size as AL graph
for i in range(len(self.al)):
for j in self.al[i]:
edge_list.insert_edge(i, j.dest, j.weight) # inserts edges
return edge_list
def ham_backtrack(V):
# Convert V as an edge list and assign it to Eh
Eh = V.as_EL()
# Create an edge list graph with the same parameters as V
el = EL.Graph(len(V.al), weighted=V.weighted, directed=V.directed)
return ham_backtrack_(el, Eh.el)
def as_EL(self):
edgelist = EL.Graph(len(self.al), self.weighted, self.directed)
for i in range(len(self.al)):
for j in self.al[i]:
edgelist.insert_edge(i, j.dest, j.weight)
return edgelist
def as_EL(self):
edgelist = EL.Graph(len(self.am), self.weighted, self.directed)
for row in range(len(self.am)):
for col in range(len(self.am[row])):
if self.am[row][col] != -1:
edgelist.insert_edge(row, col, self.am[row][col])
return edgelist
def backtracking_check(V):
Eh = V.as_EL()
el = EL.Graph(len(V.al), weighted=V.weighted, directed=V.directed)
h = backtracking_hamiltonian(el, Eh.el)
if isinstance(h, AL.Graph):
#ham.display()
return True
else:
return False
def as_EL(self):
edgelist = EL.Graph(
len(self.am), self.weighted,
self.directed) # makes a EL graph that is same size as AM graph
for row in range(len(self.am)):
for col in range(len(self.am[row])):
if self.am[row][col] != -1:
edgelist.insert_edge(row, col, self.am[row][col])
return edgelist
def as_EL(self):
g = graph_EL.Graph(len(self.al), weighted=self.weighted, directed=self.directed)
for i in range(len(self.al)):
for edge in self.al[i]:
if not self.directed:
if i < edge.dest:
g.insert_edge(i, edge.dest, edge.weight)
else:
g.insert_edge(i, edge.dest, edge.weight)
return g
def as_EL(self):
# create an empty graph with the same length as current graph
edgelist = EL.Graph(len(self.al), self.weighted, self.directed)
# insert edges using a nested loop
for i in range(len(self.al)):
for j in self.al[i]:
edgelist.insert_edge(i, j.dest, j.weight)
return edgelist
def as_EL(self):
# create an empty graph with the same length as current graph
edgelist=EL.Graph(len(self.am), self.weighted, self.directed)
# insert edges using a nested loop
for row in range(len(self.am)):
for col in range(len(self.am[row])):
if self.am[row][col]!=-1:
edgelist.insert_edge(row,col,self.am[row][col])
return edgelist
def as_EL(self):
#constructor for EL graph
g = gel.Graph(len(self.al),
weighted=self.weighted,
directed=self.directed)
for i in range(len(self.al)): #iterates through np
for j in range(len(self.al[i])): #list inside np
g.insert_edge(
i, self.al[i][j].dest,
self.al[i][j].weight) #inserts corresponding values
return g
def as_EL(self):
#creating empty edge list
edge_list = EL.Graph(len(self.al))
#iterating through edge list
for i in range(len(self.al)):
for edge in self.al[i]:
edge_list.insert_edge(i, edge.dest, edge.weight)
return edge_list
def as_EL(self):
#constructor for edge graph
g = gel.Graph(len(self.am),
weighted=self.weighted,
directed=self.directed)
for source in range(len(self.am)): #iterates length of matrix
for dest in range(len(self.am)): #iterates for width of matrix
if (self.am[source, dest] != -1): #sends only values existing
g.insert_edge(source, dest,
self.am[source,
dest]) #inserts corresponding values
return g
def am_to_el(g):
g2 = graph_EL.Graph(g.am.shape[0],
directed=g.directed,
weighted=g.weighted)
for i in range(g.am.shape[0]):
start = 0
if not g.directed:
start = i
for j in range(start, g.am.shape[0]):
if g.am[i, j] > -1:
g2.insert_edge(i, j, g.am[i, j])
return g2
def hc_check(v, e):
potential = g_EL.Graph(v)
in_degree_2 = True
for edge in e:
potential.insert_edge(edge.source, edge.dest, edge.weight)
potential = potential.as_AL()
potential_cc = cc.connected_components(potential)
for vertex in range(len(potential.al)):
if potential.in_degree(vertex) != 2:
in_degree_2 = False
if potential_cc[0] == 1 and in_degree_2 == True:
return e
return None
def as_EL(self):
g = graph_EL.Graph(len(self.am),
weighted=self.weighted,
directed=self.directed)
for i in range(len(self.am)):
for j in range(len(self.am[i])):
if self.am[i][j] != 0:
if not self.directed:
if i < j:
g.insert_edge(i, j, self.am[i][j])
else:
g.insert_edge(i, j, self.am[i][j])
return g
def as_EL(self):
g = g_EL.Graph(self.am.shape[0], weighted = self.weighted, directed = self.directed)
if self.directed:
for i in range(self.am.shape[0]):
for j in range(self.am.shape[1]):
if self.am[i][j] != -1:
g.insert_edge(i, j, self.am[i][j])
g.el.sort(key = lambda edge: edge.source)
else:
for i in range(self.am.shape[0]):
for j in range(i, self.am.shape[1]):
if self.am[i][j] != -1:
g.insert_edge(i, j, self.am[i][j])
return g
def as_EL(self):
"""
Convert an adjacency list representation of a graph to an edge list by
traversing through the original representation and calling the
insert_edge() function from the edge list class for each Edge object
in the adjacency list.
"""
EL = el_graph.Graph(len(self.al), weighted=self.weighted, directed=self.directed)
for i in range(len(self.al)):
for edge in self.al[i]:
source = i
dest = edge.dest
weight = edge.weight
EL.insert_edge(source, dest, weight)
return EL
def RandomizedHamiltion(V, E):
if len(E.el) < V:
print('Not enough Edges')
for i in range(2**(len(E.el))):
Eh = gEL.Graph(V, directed=False)
temp = np.random.randint(0, len(E.el) - 1)
while len(Eh.el) < V:
tempRev = gEL.Edge(E.el[temp].dest, E.el[temp].source)
while E.el[temp] in Eh.el or tempRev in E.el:
temp = np.random.randint(0, len(E.el) - 1)
Eh.insert_edge(E.el[temp].source, E.el[temp].dest)
temp = np.random.randint(0, len(E.el) - 1)
al = Eh.as_AL()
c, path = cycle(al)
if check(al) and c:
return path
return
def as_EL(self):
"""
Convert an adjacency matrix representation of a graph to an edge list
by traversing through the original representation and calling the
insert_edge() function from the edge list class for each edge
connecting two vertices, which is represented by the value of the edge
weight in the adjacency matrix.
"""
EL = el_graph.Graph(len(self.am),
weighted=self.weighted,
directed=self.directed)
for s in range(len(self.am)):
for d in range(len(self.am[s])):
if self.am[s][d] > 0:
source = s
dest = d
weight = self.am[s][d]
EL.insert_edge(source, dest, weight)
return EL
def BacktrackingHamiltonian(V, E):
bgraph = graph.Graph(V)
return AuxBacktrackingHamiltonian(bgraph, list(E))
def BT(V):
E = V.as_EL()
el = EL.Graph(len(V.al), weighted=V.weighted, directed=V.directed)
return Helper_BT(el,E.el)
s1[i - 1] in vowels and not s2[j - 1] in vowels):
n = [d[i, j - 1], d[i - 1, j]]
d[i, j] = min(n) + 1 #fill data with min number + 1
return d[-1, -1] #return matrix
def makeRandomGraph(G, E):
V = G.vertices
for i in range(E):
G.insert_edge(np.random.randint(V), np.random.randint(V))
return G
exit = False
g = graph.Graph(5)
g.insert_edge(0, 1)
g.insert_edge(1, 2)
g.insert_edge(1, 4)
g.insert_edge(2, 3)
g.insert_edge(3, 4)
g.insert_edge(2, 4)
g.insert_edge(4, 0)
while (not exit):
print("================================================")
print(
"Choose an algorythm to test:\n\t1) Randomization Hamiltonian\n\t2) Backtracking Hamiltonian\n\t3) Dynamic Programming\n\t4) Exit"
)
option = input(':')
if option == "1":
d[0,:] = np.arange(len(s2)+1)
d[:,0] = np.arange(len(s1)+1)
for i in range(1,len(s1)+1):
for j in range(1,len(s2)+1):
if s1[i-1] ==s2[j-1]:
d[i,j] =d[i-1,j-1]
else:
n = [d[i,j-1],d[i-1,j-1],d[i-1,j]]
if (s1[i-1].lower() in vowels and s2[j-1].lower() in vowels) or (s1[i-1].lower() not in vowels and s2[j-1].lower() not in vowels):
d[i,j] = min(n)+1
else:
d[i,j] = min(n[0], n[2]) + 1
print(d)
return d[-1,-1]
g = g_EL.Graph(3)
g.insert_edge(0, 1)
g.insert_edge(0, 2)
g.insert_edge(1,2)
el1 = g.el
el2 = []
v = g.vertices
start = time.time()
a = hc_backtrack(v, el1, el2)
end = time.time()
print('first graph hc: easy')
for edge in a:
print(edge.source, edge.dest, edge.weight)
g = g_EL.Graph(4)
g.insert_edge(0, 1)
g.insert_edge(0, 3)
import matplotlib.pyplot as plt
import numpy as np
import graph_EL as graph
#import graph_AM as graph # Replace line 3 by this one to demonstrate adjacy maxtrix implementation
#import graph_EL as graph # Replace line 3 by this one to demonstrate edge list implementation
if __name__ == "__main__":
#Part 1
plt.close("all")
g = graph.Graph(6)
g.insert_edge(0, 1)
g.insert_edge(0, 2)
g.insert_edge(1, 2)
g.insert_edge(2, 3)
g.insert_edge(3, 4)
g.insert_edge(4, 1)
#All subsequent calls to draw() need conversion to AL to be utilized
g1 = g.as_AL()
g1.draw()
g.delete_edge(1, 2)
g.display()
g1 = g.as_AL()
g1.draw()
g = graph.Graph(6, directed=True)
g.insert_edge(0, 1)
g.insert_edge(0, 2)
g.insert_edge(1, 2)
g.insert_edge(2, 3)
g.insert_edge(3, 4)
g.insert_edge(4, 1)
print('2. Puzzle')
choice2=int(input('Select choice: '))
if choice2==1:
test.tests(choice)
if choice2==2:
if choice==1:
g=AL.Graph(16)
if choice==2:
g=AM.Graph(16)
if choice==3:
g=EL.Graph(16)
g.insert_edge(0,5)
g.insert_edge(5,4)
g.insert_edge(4,7)
g.insert_edge(4,13)
g.insert_edge(2,13)
g.insert_edge(7,11)
g.insert_edge(10,11)
g.insert_edge(10,15)
timer=0
print('\n1. Breadth First Search')
print('2. Depth First Search')
splitted = True
prev.append(item)
rest = []
for i in d[item]:
stack.append(i)
else:
answer.append(prev + rest + [15])
rest = []
print("DFS Ordering for graph_EL is :", order)
print("Answer using DFS Search for graph_EL is :", answer)
# DFS for graph_EL using Stack
g = el.Graph(16, directed=True)
g.insert_edge(0, 5)
g.insert_edge(5, 4)
g.insert_edge(4, 7)
g.insert_edge(4, 13)
g.insert_edge(7, 2)
g.insert_edge(2, 11)
g.insert_edge(11, 10)
g.insert_edge(10, 15)
g.insert_edge(13, 8)
g.insert_edge(8, 11)
g.display()
#dfs() # change graph to al to use this
dfs2()
def makeGraph(V, Eh):
ngraph = graph.Graph(V)
for i in Eh:
ngraph.insert_edge(i.source, i.dest) #inserts edges
return ngraph
