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