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]))
