def __init__(self,g,start):
'''
The general algorithm is based on 3 colors
white: not visited not processed
grey: visited but not processed
black: visited and processed
The term processed means all adjacent vertices have been visited.
hence a black node can't have a white neighbor but can have grey or black neighbors
We maintain a queue of nodes to be visited and we run the algo until the queue is empty
Then for every neighbor of the currentNode, we check if it is white,set it to gray,
increment distance by 1,change neighbor's parent to current node and add neighbor to queue
Running time: O(V+E)
:param g: Graph
:param start: starting node or string
:return: None
'''
if not isinstance(start,Vertex) or not isinstance(g,Graph):
raise Exception("Invalid paramaters")
start.setDistance(0)
start.setPred(None)
self.vertQueue=Queue()
self.vertQueue.enqueue(start)
while (self.vertQueue.size()>0):
currentVert=self.vertQueue.dequeue()
for nbr in currentVert.getConnections():
if nbr.getColor()=='white':
nbr.setColor('gray')
nbr.setDistance(currentVert.getDistance()+1)
nbr.setPred(currentVert)
self.vertQueue.enqueue(nbr)
currentVert.setColor('black')
def isReachable(self,u,v):
"""
:param u: Key
:param v: Key
:return:
"""
vertList=self.getVertices()
assert(u in vertList and v in vertList)
start=self.getVertex(u)
end=self.getVertex(v)
start.setDistance(0)
start.setPred(None)
vertQueue=Queue()
vertQueue.enqueue(start)
while(vertQueue.size()!=0):
currentVert=vertQueue.dequeue()
if currentVert.getId()==end.getId():
return True
for nbr in currentVert.getConnections():
if nbr.getColor()=="white":
nbr.setColor('gray')
nbr.setPred(currentVert)
nbr.setDistance(currentVert.getDistance()+1)
vertQueue.enqueue(nbr)
currentVert.setColor('black')
return False
def cria_balcoes(num_balcoes):
global balcoes #Definição de variáveis globais para serem usadas noutras funções
balcoes=[]
for i in range(0, num_balcoes, 1):
balcao=Balcao(i, Queue(), 1, 0, 0, 0, random.randrange(1, num_bag))
# print('Balcão gerado: {}'.format(balcao)) - Print de Debugging
balcoes.append(balcao)
def simulateOneServer(file_name):
import pandas as pd
df = pd.read_csv(file_name, index_col=0, names = ['currentSecond', 'task', 'Time'])
df2 = df.reset_index()
server = Server()
requestQueue = Queue()
waitingtimes = []
starttime = df2['currentSecond'][0]
for x in range(len(df2)):
task = Task(df2['Time'][x])
requestQueue.enqueue(task)
for x in range(len(df2)):
endtime = starttime + df2['Time'][x]
starttime = endtime
nexttask = requestQueue.dequeue()
waitingtimes.append(nexttask.waitTime(starttime, df2['currentSecond'][x]))
if (not server.busy()) and (not requestQueue.isEmpty()):
server.startNext(nexttask)
server.tick()
averageWait=sum(waitingtimes)/len(waitingtimes)
print("Average Wait %6.2f secs for a single server."%(averageWait))
def bfs(self, adj_node):
adj_node.color = Color.gray
adj_node.parent_node = None
adj_node.parent_distance = 0
node_queue = Queue()
node_queue.enqueue(adj_node)
while node_queue.size() > 0:
adj_node = node_queue.dequeue()
if self.found:
break
for node_tup in adj_node.child_nodes:
vertex = node_tup[0]
assert isinstance(vertex, Node)
if vertex.color is Color.white:
vertex.color = Color.gray
vertex.parent_distance = int(node_tup[1])
vertex.parent_node = adj_node
node_queue.enqueue(vertex)
if vertex.name.strip().lower() == self.destination:
self.found = True
self.__searched_list__.append(vertex)
break
adj_node.color = Color.black
def simulation(numSeconds, tasksPerMinute):
worker1 = Worker(2)
worker2 = Worker(3)
worker3 = Worker(4)
team = Team(worker1, worker2, worker3)
taskQueue = Queue()
waitingtimes = []
for currentSecond in range(numSeconds):
if newTask():
task = Task(currentSecond)
taskQueue.enqueue(task)
if (not team.allBusy()) and (not taskQueue.isEmpty()):
nextTask = taskQueue.dequeue()
team.assignTask(nextText())
waitingtimes.append(nexttask.waitTime(currentSecond))
team.assignTask()
team.tick()
averageWait = sum(waitingtimes) #/len(waitingtimes)
print("Average Wait %6.2f secs %3d tasks remaining." %
(averageWait, taskQueue.size()))
def transpose(self):
for aVertex in self:
aVertex.setColor('white')
for key in self.vertices:
start = self.vertices[key]
break
vertQueue = Queue()
vertQueue.enqueue(start)
while vertQueue.size() > 0:
currentVert = vertQueue.dequeue()
toDel = []
for nbr in currentVert.getConnections():
# here is the key
if currentVert.connectedTo[nbr] != -1:
nbr.connectedTo[currentVert] = -1
toDel.append(nbr)
if nbr.getColor() == 'white':
vertQueue.enqueue(nbr)
for vertex in toDel:
if currentVert.connectedTo[vertex] == 0:
del currentVert.connectedTo[vertex]
currentVert.setColor('black')
def __init__(self, n_balcao, num_bag):
self.__n_balcao = n_balcao
self.__fila = Queue()
self.__inic_atend = 0
self.__passt_atend = 0
self.__numt_bag = 0
self.__tempt_esp = 0
self.__bag_utemp = randint(1, int(num_bag))
def __init__(self, n_balcao, bag_utemp):
self.n_balcao = n_balcao
self.fila = Queue()
self.inic_atend = 0
self.passt_atend = 0
self.numt_bag = 0
self.tempt_esp = 0
self.bag_utemp = bag_utemp
def hotPotato(names, num):
q = Queue()
for ele in names:
q.enqueue(ele)
while q.size() > 1:
for i in range(num):
q.enqueue(q.dequeue())
q.dequeue()
return q.dequeue()
def __init__(self,n_balcao,fila,inic_atend,passt_atend,numt_bag,tempt_esp,bag_utemp):
self.n_balcao = n_balcao
self.fila = Queue()
self.inic_atend = inic_atend
self.passt_atend = passt_atend
self.numt_bag = numt_bag
self.tempt_esp = tempt_esp
self.bag_utemp = random.randint(1, num_bag)
self.namesPass = names.get_full_name()
def hotpotato(li, n):
simqueue = Queue()
for i in li:
simqueue.enqueue(i)
while simqueue.size() > 1:
for i in range(n):
simqueue.enqueue(simqueue.dequeue())
simqueue.dequeue()
return simqueue.dequeue()
def hotLine(namelist, num):
simqueue = Queue()
for name in namelist:
simqueue.enqueue(name)
while simqueue.size() > 1:
for i in range(num):
simqueue.enqueue(simqueue.dequeue())
simqueue.dequeue()
return simqueue.dequeue()
def hotline(namelist, num):
s = Queue()
for name in namelist:
s.enqueue(name)
#return s.size()
while s.size() > 1:
for i in range(num):
s.enqueue(s.dequeue())
s.dequeue()
return s.dequeue()
def test(self, wordStart):
if self.isNoChain(wordStart):
return False
start = self.graph.getVertex(wordStart)
start.setDistance(0)
start.setPred(None)
vrtxQueue = Queue()
vrtxQueue.enqueue(start)
#print(wordStart,end='')
d = defaultdict(list)
while vrtxQueue.size() > 0:
ls = []
current = vrtxQueue.dequeue()
#print(current.getId(),end='')
prev = None
for neighbour in current.getConnections():
if neighbour.getColor() == "white":
neighbour.setColor("gray")
neighbour.setDistance(current.getDistance() + 1)
neighbour.setPred(current)
dist = neighbour.getDistance()
word = neighbour.getId()
d[dist].append(word)
#print("->"+neighbour.getId(),end='')
ls.append(neighbour)
##if neighbour.getId() == wordEnd :
# print("\n\n\t",end='');
#vrtxQueue.enqueue(neighbour)
for i in range(len(ls)):
vrtxQueue.enqueue(ls.pop(0))
current.setColor("black")
outfile = open('Chains.txt', 'a')
print("WORD : " + wordStart, file=outfile)
for length in d.keys():
print(
'----------------------- Length : {} -----------------------'.
format(length),
file=outfile)
self.frequency.setdefault(length, 0)
self.frequency[length] += len(d[length])
for word in d[length]:
vert = self.graph.getVertex(word)
print(vert.getId(), end='', file=outfile)
for count in range(length):
print(" -> " + vert.getPred().getId(),
end='',
file=outfile)
#print()
vert = vert.getPred()
print(file=outfile)
print(file=outfile)
def hot_potato(namelist, num):
queue = Queue()
for name in namelist:
queue.enqueue(name)
while queue.size() > 1:
for _ in range(num):
queue.enqueue(queue.dequeue())
queue.dequeue()
return queue.dequeue()
def bfs(g,start):
start.setDistance(0)
start.setPred(None)
vertQueue = Queue()
vertQueue.enqueue(start)
while (vertQueue.size() > 0): currentVert = vertQueue.dequeue()
for nbr in currentVert.getConnections(): if (nbr.getColor() == 'white'):
nbr.setColor('gray')
nbr.setDistance(currentVert.getDistance() + 1)
nbr.setPred(currentVert)
vertQueue.enqueue(nbr)
def hot_potato(name, num=None):
# num = random.randint(1,20)
q = Queue()
for n in name:
q.enqueue(n)
while q.size() > 1:
for _ in range(num):
q.enqueue(q.dequeue())
q.dequeue()
return q.dequeue()
def preExpre(aStr):
operatorStack = Stack()
operandStack = Queue()
prec = {}
prec["*"] = 3
prec["/"] = 3
prec["+"] = 2
prec["-"] = 1
prec["("] = 0
tokenStr = aStr.split()
preExpressen = []
def hotPotato(namelist, num):
simqueue = Queue()
for name in namelist:
simqueue.enqueue(name)
while simqueue.size() > 1:
for i in range(random.randrange(1,num)):
simqueue.enqueue(simqueue.dequeue())
simqueue.dequeue()
return simqueue.dequeue()
def hot_potato_simulator(name_list, num):
simple_queue = Queue()
for name in name_list:
simple_queue.enqueue(name)
while simple_queue.size() > 1:
for i in range(num):
simple_queue.enqueue(simple_queue.dequeue())
simple_queue.dequeue()
return simple_queue.dequeue()
def hot(names,num): simque = Queue() for name in names: simque.enqueue(name) while simque.size() > 1: for i in range(num): simque.enqueue(simque,dequeue()) simque.dequeue() return simque.dequeue()
def hotPotato(namelist, num):
playQueue = Queue()
for name in namelist:
playQueue.enqueue(name)
while playQueue.size() > 1:
for i in range(num):
player = playQueue.dequeue()
playQueue.enqueue(player)
else:
playQueue.dequeue()
return playQueue.dequeue()
def simulateManyServers(file_name, servers):
import pandas as pd
df = pd.read_csv(file_name, index_col=0, names = ['currentSecond', 'task', 'Time'])
df2 = df.reset_index()
df2['RoundRobin'] = ''
networks = servers
orig_networks = servers
for x in range(len(df2)):
df2.at[x, 'RoundRobin'] = networks
networks -= 1
if networks == 0:
networks = orig_networks
for x in range(1, orig_networks + 1):
df3 = df2[df2['RoundRobin']==x]
df3.reset_index(inplace=True)
server = Server()
requestQueue = Queue()
waitingtimes = []
starttime = df3['currentSecond'][0]
for x in range(len(df3)):
task = Task(df3['Time'][x])
requestQueue.enqueue(task)
for x in range(len(df3)):
endtime = starttime + df3['Time'][x]
if df3['currentSecond'][x] > endtime:
starttime = df3['currentSecond'][x]
else:
starttime = endtime
nexttask = requestQueue.dequeue()
waitingtimes.append(nexttask.waitTime(starttime, df3['currentSecond'][x]))
if (not server.busy()) and (not requestQueue.isEmpty()):
server.startNext(nexttask)
# all_waitingtimes.append(averagesubWait)
server.tick()
averageWait=sum(waitingtimes)/len(waitingtimes)
print("Average Wait {} secs for {} servers.".format("{:.2f}".format(round(averageWait,2)), servers))
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
def bfs(g, start):
start.setDistance(0)
start.setPred(None)
vertQueue = Queue()
vertQueue.enqueue(start)
while (vertQueue.size() > 0):
currentVert = vertQueue.dequeue()
for nbr in currentVert.getConnections():
if nbr.getColor() == "while":
nbr.setColor("gray")
nbr.setDistance(currentVert.getDistance + 1)
nbr.setPred(currentVert)
vertQueue.enqueue(nbr)
currentVert.setColor("black")
def hotPotato(namelist):
simqueue = Queue()
for name in namelist:
simqueue.enqueue(name)
length = len(namelist)
randomor = random.Random()
while simqueue.size() > 1:
num = randomor.randrange(length, 2 * length + 1)
for i in range(num):
simqueue.enqueue(simqueue.dequeue())
simqueue.dequeue()
return simqueue.dequeue()
def bfs(g, start):
start.setDistance(0) #起点的距离设为0
start.setPred(None) #起点没有父节点
vertQueue = Queue() #建立一个队列
vertQueue.enqueue(start) #将起点加入队列中
while (vertQueue.size() > 0): #当队列存在对象时
currentVert = vertQueue.dequeue() #弹出对象并设置为当前节点
"""该迭代阐明了bfs的特点就是把每个邻居都遍历，先完成一层，再往下完成，“广”"""
for nbr in currentVert.getConnections(): #搜索当前节点的所有邻居
if (nbr.getColor() == 'white'): #如果邻居x是白色的（即待搜索）
nbr.setColor('gray') #设为灰色意为正在处理
nbr.setDistance(currentVert.getDistance() + 1) #该邻居距离为当前节点+1
nbr.setPred(currentVert) #该邻居的父节点是当前节点
vertQueue.enqueue(nbr) #队列加入该邻居
def breadthFirstSearch(start):
start.setDistance(0)
start.setPred(None)
vertQueue = Queue()
vertQueue.enqueue(start)
while vertQueue.size() > 0:
dequeueVert = vertQueue.dequeue()
for neighbor in dequeueVert.getConnections():
if neighbor.getColor() == 'white':
vertQueue.enqueue(neighbor)
neighbor.setColor('gray')
neighbor.setDistance(dequeueVert.getDistance() + 1)
neighbor.setPred(dequeueVert)
dequeueVert.setColor('black')
def simulation(total_seconds, pages_per_minute):
queue, wait_times = Queue(), []
printer = Printer(pages_per_minute)
for second in range(total_seconds):
if new_print_task():
queue.enqueue(Task(second))
if not printer.busy() and not queue.is_empty():
task = queue.dequeue()
wait_times.append(task.wait_time(second))
printer.start_next(task)
printer.tick()
print(f'Average Wait {sum(wait_times) / len(wait_times):6.2f} secs {queue.size():2d} tasks remaining.')
