def build_graph_with_word_file(word_file): """ This :param word_file: :return: graph Object """ d = {} g = Graph() wfile = open(word_file, 'r') # create buckets of words that # differ by one letter for line in wfile: word = line[:-1] for i in range(len(word)): bucket = word[:i] + '_' + word[i + 1:] if bucket in d: d[bucket].append(word) else: d[bucket] = [word] # add vertices and edges for words # in the same bucket for bucket in d.keys(): for word1 in d[bucket]: for word2 in d[bucket]: if word1 != word2: g.addEdge(word1, word2, randint(0, 9)) # g.addEdge(word2, word1, randint(0, 9)) # print(d) return g
def build_graph(word_file): d = {} g = Graph() wfile = open(word_file, 'r') # Create buckets of words that differ by one letter for line in wfile: word = line[:-1] for i in range(len(word)): bucket = word[:i] + '_' + word[i + 1:] if bucket in d: d[bucket].append(word) else: d[bucket] = [word] for word in d.keys(): print(word, ':', d[word]) # Add vertices and edges for words in the same bucket for bucket in d.keys(): for word1 in d[bucket]: for word2 in d[bucket]: if word2 != word1: g.addEdge(word1, word2) return g
def build_graph(g_map) -> Graph: g = Graph() for u in g_map: for v, w in g_map[u].items(): g.add_edge(u, v, w) return g
def __init__(self): self.d = {} self.g = Graph() self.ve = Vertex self.lines = [] self.spe = [[], []] self.x = 0 with open("content/C_10_50.mis", encoding='UTF-8') as f: sizes = f.readline() sp = sizes.split(" ") # print(sp) amt_node = int(sp[2]) # print(amt_node) amt_edges = int(sp[3]) next(f) self.lines = f.readlines() f.close() for i in self.lines: x = i[:-1].split(' ', 3) self.spe[0].append(x[1]) self.spe[1].append(x[2]) # self.g = Graph() for i in range(int(amt_node)): self.g.addVertex(i) self.g.addEdge((int(self.spe[1][i])), int(self.spe[0][i]))
def buildGraph(filename): payG = Graph() for users in genUser(filename): payG.addEdge(users[0], users[1]) return payG
def buildGraph(keys,length): d = {} g = Graph() #wfile = open(wordFile,'r') # create buckets of words that differ by one letter for k in keys: if(k.find('-') ==-1 and len(k) == length): #word = k[:-1] word = k #print word for i in range(len(word)): bucket = word[:i] + '_' + word[i+1:] if bucket in d: d[bucket].append(word) else: d[bucket] = [word] #for p in d['WEA_']: Prints bucket # print p # add vertices and edges for words in the same bucket for bucket in d.keys(): for word1 in d[bucket]: for word2 in d[bucket]: if word1 != word2: g.addEdge(word1,word2) return g
def __init__(self): self.dictionary = {} self.graph = Graph() self.wordContainer = {} self.fileName = 'dictionary.json' self.noChain = [] self.frequency = {}
def buildGraph(): d = {} g = Graph() word_list = ["fool", "pool", "poll", "pole", "pale", "page", "sage"] # create buckets of words that differ by one letter for word in word_list: for i in range(len(word)): bucket = word[:i] + '_' + word[i + 1:] if bucket in d: d[bucket].append(word) else: d[bucket] = [word] print(d) print(len(d)) s = 0 for i in d.values(): s += len(i) print(s) # add vertices and edges for words in the same bucket for bucket in d.keys(): for word1 in d[bucket]: for word2 in d[bucket]: if word1 != word2: g.addEdge(word1, word2) return g
def knightGraph(bdsize): ktgraph = Graph() for row in range(bdsize): for col in range(bdsize): nodeId = posTonodeId(row,col,bdsize) legalMovesID = genLegalMovesID(row,col,bdsize) for move in legalMovesID: ktgraph.addEdge(nodeId,move) return ktgraph
def knightGraph(bds): g = Graph() for row in range(bds): for col in range(bds): hull = gennumb(row,col,bds) node1 = genLegalMoves(row,col,bds) for j in node1: g.addEdge(hull,j) return g
def transpose(self, startVertex): g = Graph() for nextVertex in startVertex.getConnections(): if nextVertex.getColor() == 'white': g.addEdge(nextVertex, startVertex) nextVertex.setColor('gray') self.transpose(nextVertex) startVertex.setColor('black') return g
def knightGraph(bdSize): ktGraph = Graph() for row in range(bdSize): for col in range(bdSize): nodeId = posToNodeId(row,col,bdSize) newPositions = genLegalMoves(row,col,bdSize) for e in newPositions: nid = posToNodeId(e[0],e[1],bdSize) ktGraph.addEdge(nodeId,nid) return ktGraph
def knightGraph(bdSize): ktGraph = Graph() for row in range(bdSize): for col in range(bdSize): nodeId = posToNodeId(row, col, bdSize) newPositions = genLegalMoves(row, col, bdSize) for e in newPositions: nid = posToNodeId(e[0], e[1], bdSize) ktGraph.addEdge(nodeId, nid) return ktGraph
def knightGraph(boardSize): graph = Graph() for row in range(boardSize): for col in range(boardSize): boardNodeId = row * boardSize + col newPosition = legalMoves(row, col, boardSize) for node in newPosition: newNodeId = node[0] * boardSize + node[1] graph.addEdge(boardNodeId, newNodeId) return graph
def buildGraph(bdsize): ktGraph = Graph() for row in range(bdsize): for col in range(bdsize): nodeId = getNodeId(row, col, bdsize) legalMoves = getLegalMoves(row, col, bdsize) for options in legalMoves: nid = getNodeId(options[0], options[1], bdsize) ktGraph.addEdge(nodeId, nid) return ktGraph
def setUp(self): g = Graph() g.addEdge(0, 1) g.addEdge(0, 2) g.addEdge(0, 3) g.addEdge(2, 0) g.addEdge(2, 1) g.addEdge(1, 3) self.graph = g self.start = g.getVertex(2) self.target = g.getVertex(3)
def knightGraph(bdDize): #makes one pass over the entire board, helper function ktGraph = Graph() for row in range(bdSize): for col in range(bdSize): nodeId = posToNodeId(row,col,bdSize) newPositions = genLegalMoves(row,col,bdSize) for e in newPositions: nid = posToNodeId(e[0],e[1],bdSize) ktGraph.addEdge(nodeId,nid) return ktGraph
def buildGraph(counts): d = {'miss': (3, 2, 1, 0), 'cann': (3, 2, 1, 0), 'boat': (1, 0)} g = Graph() counts = counts # add vertices and edges for carying counts on the initial beach for counts in d.keys(): for state1 in d[counts]: for state2 in d[counts]: if state1 != state2: g.addEdge(state1, state2) return g
def knightpathgraph(bdsize): ktgraph = Graph() #Empty Graph for row in range(bdsize+1): #Iterating through rows and columns for col in range(bdsize+1): nodeID = convloctoNode(row,col,bdsize) #Converting the rows and cols position to a Node legalmov = genlegalmov(row,col,bdsize) #Calculating all the available moves of a knight for e in legalmov: #Iterating through all the available moves newid = convloctoNode(e[0],e[1],bdsize) #Converting the available move into a Node ktgraph.addEdge(nodeID,newid) #Adding edge betwwen the current Node and the available Node return ktgraph #Thus, a graph of moves is built
def knightGraph(bdSize): """ create graph and all the vertices(spots on board) and edges(legal moves)""" g = Graph() for row in range(bdSize): for col in range(bdSize): # for each cell figure out its possible next moves and create edges pos = posToNodeId(row,col,bdSize) moves = genLegalMoves(row,col,bdSize) for move in moves: movePos = posToNodeId(move[0],move[1],bdSize) g.addEdge(pos,movePos) return g
def mst(matrix, s): for i in range(len(matrix)): matrix[i][i] = sys.maxint graph = Graph() for i in range(len(matrix)): for j in range(len(matrix)): graph.addEdge(i, j, matrix[i][j]) prim(graph, graph.getVertex(s)) sum = 0 for each in graph: sum += each.getDistance() return sum
def knightGraph(bdSize): ktGraph = Graph() for row in range(bdSize): for col in range(bdSize): nodeId = posToNodeId(row, col, bdSize) newPositions = genLegalMoves(row, col, bdSize) for e in newPositions: nid = posToNodeId(e[0], e[1], bdSize) ktGraph.addEdge(nodeId, nid) path = [] limit = bdSize * bdSize currentVertex = ktGraph.getVertex(0) x = knightTour(0, path, currentVertex, limit) y = path
def build_graph(words): dictionary = {} g = Graph() for word in words: for i in range(len(word)): group = word[:i] + '_' + word[i + 1:] if group in dictionary: dictionary[group].append(word) else: dictionary[group] = [word] for group in dictionary.keys(): for word1 in dictionary[group]: for word2 in dictionary[group]: if word1 != word2: g.addEdge(word1, word2) return g
def buildGraph(word): d = {} g = Graph() for n in range(len(word)): bucket = word[:n] + "_" + word[n + 1:] if bucket in d: d[bucket].append(word) else: d[bucket] = [word] for bucket in d.keys(): for word1 in d[bucket]: for word2 in d[bucket]: if word1 != word2: g.addEdge(word1, word2) return g
class adjGraphTests(unittest.TestCase): def setUp(self): self.tGraph = Graph() def testMakeGraph(self): with open("./tests/test.dat") as gFile: for line in gFile: fVertex, tVertex = line.split('|') fVertex = int(fVertex) tVertex = int(tVertex) self.tGraph.addEdge(fVertex,tVertex) for i in self.tGraph: adj = i.getConnections() for k in adj: print(i.getId(), k.getId())
def test_positive_detection_cycle(self): graph = Graph() graph.addEdge(1, 0) graph.addEdge(0, 2) graph.addEdge(2, 0) graph.addEdge(0, 3) graph.addEdge(3, 4) cd = CycleDetector(graph) print(cd.cycle_exists_directed())
def build_graph(): g = Graph() # a->b->c->d->a, d->b g.addEdge('a', 'b', 4) g.addEdge('b', 'c', 5) g.addEdge('c', 'd', 3) g.addEdge('d', 'a', 2) g.addEdge('b', 'd', 1) return g
def traversal(g: Graph, end) -> list: res = [] vertex = g.get_vertex(end) while vertex: res.append(vertex.id) vertex = vertex.predecessor return res
def _build_graph(self) -> Graph: g = Graph() for y in range(self.board_size): for x in range(self.board_size): for pos in self._next_position(x, y): self._add_edge(g, (x, y), pos) return g
def buildGraph(wdict): d = {} g = Graph() for word in wdict: for i in range(len(word)): bucket = word[:i] + '_' + word[i + 1:] if bucket in d: d[bucket].append(word) else: d[bucket] = [word] for bucket in d.keys(): for word1 in d[bucket]: for word2 in d[bucket]: if word1 != word2: g.addEdge(word1, word2) return g
def buildGraph(wordFile): d = defaultdict(list) g = Graph() wordList = open(wordFile,'r').read().strip().split(',') # create a hash table for word in wordList: for i in range(len(word)): bucket = word[:i] + '_' + word[i+1:] d[bucket].append(word) # create a graph for bucket in d.keys(): for word1 in d[bucket]: for word2 in d[bucket]: if word1 != word2: g.addEdge(word1,word2) return g
def buildGraph(wordFile): d = {} g = Graph() wfile = open(wordFile, 'r') for line in wfile: word = line[:-1] for i in range(len(word)): bucket = word[:i] + '_' + word[i + 1:] if bucket in d: d[bucket].append(word) else: d[bucket] = [word] for bucket in d.keys(): for word1 in d[bucket]: for word2 in d[bucket]: if word1 != word2: g.addEdge(word1, word2) return g
def build_graph(word_list): d = {} g = Graph() # create buckets of words that differ by one letter for word in word_list: for i in range(len(word)): bucket = word[:i] + '_' + word[i + 1:] if bucket in d: d[bucket].append(word) else: d[bucket] = [word] # add vertices and edges for words in the same bucket for bucket in d.keys(): for word1 in d[bucket]: for word2 in d[bucket]: if word1 != word2: g.add_edge(word1, word2) return g
def buildGraph(wordFile): d = {} g = Graph() wfile = open(wordFile, 'r') lines = wfile.readlines() for line in lines: word = line.strip('\n') for i in range(len(word)): bucket = word[:i] + "_" + word[i + 1:] if bucket in d: d[bucket].append(word) else: d[bucket] = [word] for bucket in d.keys(): for word1 in d[bucket]: for word2 in d[bucket]: if word1 != word2: g.addEdge(word1, word2) return g
def buildGraph(wordFile): d = {} g = Graph() wfile = open(wordFile, 'r') # create buckets of words that differ by one letter for line in wfile: word = line[:-1] for i in range(len(word)): bucket = word[:-1] + '_' + word[i+1:] if bucket in d: d[bucket].append(word) else: d[bucket] = [word] # add vertices and edges for words in the same bucket for bucket in d.keys(): for word1 in d[bucket]: if word1 != word2: g.addEdge(word1,word2) return g
def buildGraph(filename): """ Parses edge file and builds graph Args: filename (str): input file name of edges file -- "source_id target_id" Returns: graph: edges (int(source), int(target)) """ g = Graph() widgets = ['Building graph: ', Percentage(), ' ', Bar()] output = subprocess.check_output(["wc", "-l", filename]).split(' ') num_lines = int(output[0]) pbar = ProgressBar(widgets=widgets, maxval=num_lines).start() with open(filename, 'r') as f: for i in range(num_lines): line = f.readline() line = line.strip() line = line.split(" ") g.addEdge(int(line[SOURCE]), int(line[TARGET])) pbar.update(i+1) pbar.finish() return g
def buildGraph(wordDoc): d = {} g = Graph() wfile = open(wordFile, 'r') #create bucket of words that differ by one letter and add the word to the bucket. for line in wordFile: #Assuming word file has 1 word per line word = line.strip() for i in range(len(word)): bucket = word[:i] + '_' + word[i+1:] if bucket in d: d[bucket].append[word] else: d[bucket] = [word] #Connect words in same bucket with edges. for bucket in d: for word1 in bucket: for word2 in bucket: if word1 != word2: g.addEdge(word1,word2) return g
def main(): #file opening alphabet = "abcdefghijklmnopqrstuvwxyz" #file parsing word = [] for line in fileinput.input(): x = line.strip() t = x.lower() word.append(t) fileinput.close() g = Graph() for i in word: vertlist = g.getVertices() if i not in vertlist: g.addVertex(i) #vert0 = g.getVertex(i) fhalf = shalf = [] tmp = [] for idx,ch in enumerate(i): l = list(i) for a in alphabet: l[idx] = a final = "".join(l) if final in word and final not in vertlist: g.addVertex(final) vertlist = g.getVertices() if final in word and final in vertlist: #vert1 = g.getVertex(final) g.addEdge(i, final) g.addEdge(final, i) go = g.getVertex(i) s = go.getConnections() print i, len(s) return 0
import sys sys.setrecursionlimit(1000000000) from pythonds.graphs import Graph from pythonds.basic import Stack from pythonds.basic import Queue stk=Stack() g=Graph() i=0 finishingTime=0 l={} g1=Graph() q=Queue() temp=[] def myDfs(currentVertex): currentVertex.setColor("gray") for vertex in currentVertex.getConnections(): if vertex.getColor()=="white": myDfs(vertex) currentVertex.setColor("black") print currentVertex.getId() temp.append(currentVertex.getId()) return temp def Dfs(vertex): print "passed vertex",vertex.getId() stk.push(vertex) while stk.isEmpty()==False: currentVertex=stk.pop() global finishingTime currentVertex.setColor("gray") for vertex in currentVertex.getConnections():
pq=PriorityQueue() for vertex in Graph: vertex.setDistance(sys.maxsize) vertex.setPred(None) startVertex.setDistance(0) pq.buildHeap([(v.getDistance(),v) for v in Graph]) while not pq.isEmpty(): currentVertex=pq.delMin() for vertex in currentVertex.getConnections(): newCost=currentVertex.getDistance()+currentVertex.getWeight(vertex) if newCost<vertex.getDistance(): vertex.setDistance(newCost) vertex.setPred(currentVertex) pq.decreaseKey(vertex,newCost) G=Graph() G.addEdge("u","v",2) G.addEdge("v","u",2) G.addEdge("v","w",3) G.addEdge("w","v",3) G.addEdge("u","w",5) G.addEdge("w","u",5) G.addEdge("u","x",1) G.addEdge("x","u",1) G.addEdge("x","v",2) G.addEdge("v","x",2) G.addEdge("x","v",2) G.addEdge("x","w",3) G.addEdge("w","x",3) ''' G.addEdge("x","y",1)
from pythonds.graphs import Graph from bfs import bfs d={} g=Graph() def buildGraph(list): for word in list: for i in range(len(word)): bucket=word[:i]+"_"+word[i+1:] if bucket in d: d[bucket].append(word) else: d[bucket]=[word] for bucket in d.keys(): for word1 in d[bucket]: for word2 in d[bucket]: if (word1!=word2): g.addEdge(word1,word2) ''' buildGraph(["hit","hot","dot","dog","lot","log","cog"]) for v in g: for w in v.getConnections(): print("( %s , %s )" % (v.getId(), w.getId())) bfs(g,g.getVertex("hit"),"cog") ''' buildGraph(["fool","foul","foil","fail","fall","cool","pool", "poll","pall","pole","pope","pale","sale","sage","page"])
# 5: [2], # 6: [5], # 7: [3, 6], # 8: [4, 7] } graph = {1: [2, 8], 2: [1, 8, 3], 3: [2, 4, 6, 9], 4: [3, 5, 6], 5: [4, 6], 6: [3, 5, 7, 4], 7: [6, 8, 9], 8: [1, 2, 7, 9], 9: [3, 7, 8]} # 1. Create graph graphl = Graph() for k,v in graph.iteritems(): graphl.addVertex(k) for i in v: graphl.addEdge(k, i) # 2. Draw the graph draw_graph(graph, len(edges) ) # 3. Run the algorithm dfs(graphl) pause(30)
pq.buildHeap([(v.getDistance(),v) for v in Graph]) while not pq.isEmpty(): currentVertex=pq.delMin() pred=currentVertex.getPred() if pred: print ("( %s ,%s , %d)" % (currentVertex.getId(),pred.getId(),currentVertex.getDistance())) print currentVertex.getId(), for vertex in currentVertex.getConnections(): newCost=currentVertex.getWeight(vertex) if newCost<vertex.getDistance(): vertex.setDistance(newCost) vertex.setPred(currentVertex) pq.decreaseKey(vertex,newCost) G=Graph() G.addEdge("a","b",2) G.addEdge("b","a",2) G.addEdge("a","c",3) G.addEdge("c","a",3) G.addEdge("b","c",1) G.addEdge("c","b",1) G.addEdge("b","d",1) G.addEdge("d","b",1) G.addEdge("b","e",4) G.addEdge("e","b",4) G.addEdge("d","e",1) G.addEdge("e","d",1) G.addEdge("c","f",5) G.addEdge("f","c",5) G.addEdge("e","f",1)
from pythonds.graphs import Graph def Dfs(currentVertex): currentVertex.setColor("gray") for vertex in currentVertex.getConnections(): if vertex.getColor()=="white": Dfs(vertex) currentVertex.setColor("black") print currentVertex.getId() g=Graph() g.addEdge(0,1) g.addEdge(0,3) g.addEdge(1,2) g.addEdge(1,3) g.addEdge(3,4) g.addEdge(4,5) g.addEdge(4,1) g.addEdge(5,2) Dfs(g.getVertex(0))
import sys sys.setrecursionlimit(1000000000) from pythonds.graphs import Graph g=Graph() i=0 finishingTime=0 l={} g1=Graph() temp=[] def myDfs(currentVertex): currentVertex.setColor("gray") for vertex in currentVertex.getConnections(): if vertex.getColor()=="white": myDfs(vertex) currentVertex.setColor("black") temp.append(currentVertex.getId()) return temp def Dfs(currentVertex): global finishingTime currentVertex.setColor("gray") for vertex in currentVertex.getConnections(): vertex.incomings.append(currentVertex) if vertex.getColor()=="white": Dfs(vertex) currentVertex.setColor("black") finishingTime+=1 l[finishingTime]=currentVertex.getId()
import sys sys.setrecursionlimit(1000000000) from pythonds.graphs import Graph g=Graph() def getId(row,column,size): return row*size+column def inDifferentRows(id1,id2,size): return not int(id1/size)==int(id2/size) def getTupleFromId(id,size): return def isTupleValid(nodeId,tuple,size): tup1=(int(nodeId/size),nodeId%size) newTuple=(tup1[0]+tuple[0],tup1[1]+tuple[1]) return (newTuple[0] in range(size)) & (newTuple[1] in range(size)) def getPossibleNodeIds(size,nodeId): validIds=[] tuples=[(-1,-2),(1,-2),(-1,2),(1,2),(-2,-1),(2,-1),(-2,1),(2,1)] for tup in tuples: connectionId=nodeId+getId(tup[0],tup[1],size) if isTupleValid(nodeId,tup,size): validIds.append(connectionId) if(nodeId==13): print validIds return validIds def buildGraph(size): for i in range(size):
from pythonds.basic import Queue def pathExists(start,end): vertexQueue=Queue() vertexQueue.enqueue(start) while (vertexQueue.size()>0): item=vertexQueue.dequeue() if item.getId()==end.getId(): print ("path exists") return True else: for vertex in item.getConnections(): if vertex.getColor()=="white": vertex.setColor("gray") vertexQueue.enqueue(vertex) return False g=Graph() data=True while data!=1000: data=input("enter tuple") if data!=1000: g.addEdge(data[0],data[1]) while(True): tuple=input("Please enter tuple u want to know the path") print pathExists(g.getVertex(tuple[0]),g.getVertex(tuple[1])) for vertex in g.getVertices(): g.getVertex(vertex).setColor("white")
from pythonds.graphs import Graph from pythonds.basic import Queue queue=Queue() graph=Graph(); start=graph.addVertex("0,0") def extractQuantity(quantities): quants=quantities.split(",") return [int(quants[0]),int(quants[1])] def makeVertex(list): newList=[str(list[0]),str(list[1])] return ",".join(newList) def findPossibleChildrens(vertex,q1,q2): childrens=[] quantities=extractQuantity(vertex.getId()) quant1=quantities[0] quant2=quantities[1] # first quantity to river if not quant1==0: childrens.append(makeVertex([0,quant2])) if not quant2==q2: canHold=q2-quant2 if(canHold>=quant1): temp2=quant2+quant1 temp1=0 else: temp2=canHold temp1=abs(canHold-quant1) childrens.append(makeVertex([temp1,temp2]))