class Customs:
def __init__(self, gate_num, duration, arrive_interval, check_interval):
self.simulation = Simulation(duration)
self.waitline = SQueue()
self.duration = duration
self.gates = [0] * gate_num
self.total_wait_time = 0
self.total_used_time = 0
self.car_num = 0
self.arrive_interval = arrive_interval
self.check_interval = check_interval
def wait_time_acc(self, n):
self.total_wait_time = self.total_wait_time + n
def used_time_acc(self, n):
self.total_used_time = self.total_used_time + n
def car_count_acc(self):
self.car_num = self.car_num + 1
def add_event(self, event):
self.simulation.add_event(event)
def cur_time(self):
return self.simulation.cur_time()
def enqueue(self, car):
self.waitline.enqueue(car)
def has_queued_car(self):
return not self.waitline.is_empty()
def next_car(self):
return self.waitline.dequeue()
def find_gate(self):
for i in range(len(self.gates)):
if self.gates[i] == 0:
self.gates[i] = 1
return i
return None
def free_gate(self, i):
if self.gates[i] == 1:
self.gates[i] = 0
else:
raise ValueError("Clear gate error")
def simulate(self):
Arrive(0, self) #initially generate one car
self.simulation.run()
self.statistics()
def statistics(self):
pass
def levelorder(t, proc):
qu = SQueue()
qu.enqueue(t)
while not qu.is_empty():
n = qu.dequeue()
if n is None: # 如果弹出的树为空的话，直接跳过
continue
qu.enqueue(n.left)
qu.enqueue(n.right)
proc(n.data)
def __init__(self, gate_num, duration, arrive_interval, check_interval):
self.simulation = Simulation(duration)
self.waitline = SQueue()
self.duration = duration
self.gates = [0] * gate_num
self.total_wait_time = 0
self.total_used_time = 0
self.car_num = 0
self.arrive_interval = arrive_interval
self.check_interval = check_interval
def wfs_traverse(t, proc): #wfs 先根序
qu = SQueue()
qu.enqueue(t)
while not qu.is_empty():
t = qu.dequeue()
if t is None:
continue
qu.enqueue(t.left)
qu.enqueue(t.right)
proc(t.data)
def topo_sort(graph):
vertex_num = graph.get_ver_num()
indegree, topo_seq = [0] * vertex_num, []
for vi in range(vertex_num):
for v, w in graph.get_outedges(vi):
indegree[v] = indegree[v] + 1
qu = SQueue()
for vi in range(vertex_num):
if indegree[vi] == 0:
qu.enqueue(vi)
if qu.is_empty():
return False
while not qu.is_empty():
v_non_in = qu.dequeue()
topo_seq.append(v_non_in)
for v, w in graph.get_outedges(v_non_in):
indegree[v] = indegree[v] - 1
if indegree[v] == 0:
qu.enqueue(v)
return topo_seq
def level_order(tree, func):
q = SQueue()
q.enqueue(tree)
while not q.is_empty():
tree = q.dequeue()
if tree is None:
continue
q.enqueue(tree.left)
q.enqueue(tree.right)
func(tree.root)
def bfs(graph, s):
queue = SQueue()
queue.enqueue(s)
seen = set()
seen.add(s)
while not queue.is_empty():
vertex = queue.dequeue()
nodes = graph[vertex]
for i in nodes:
if i not in seen:
queue.enqueue(i)
seen.add(i)
print vertex
def BFS_graph(graph, v0):
vnum = graph.vertex_num()
visited = [0] * vnum
visited[v0] = 1
BFS_seq = [v0]
qu = SQueue()
qu.enqueue(graph.out_edges(v0))
while not qu.is_empty():
edges = qu.dequeue()
for i in range(len(edges)):
v, e = edges[i]
if not visited[v]:
BFS_seq.append[v]
visited[v] = 1
qu.enqueue(graph.out_edges(v))
return BFS_seq
def find_path_queue(maze, start, end):
if start == end:
print('path find')
q = SQueue()
mark(maze, start)
q.enqueue(start)
while not q.is_empty():
pos = q.dequeue()
for i in range(4):
next_p = (pos[0]+dirs[i][0], pos[1]+dirs[i][1])
if possible(maze, next_p):
if next_p == end:
print('path find')
return
mark(maze, next_p)
q.enqueue(next_p)
print('no path')
def BFS_SpanTree(graph, v0):
vertex_num = graph.get_ver_num()
bfs_spantree = []
visited = [0] * vertex_num
visited[v0] = 1
qu = SQueue()
qu.enqueue((v0, graph.get_outedges(v0)))
while not qu.is_empty():
prev_v, edges = qu.dequeue()
for i in range(len(edges)):
v, w = edges[i]
if not visited[v]:
visited[v] = 1
qu.enqueue((v0, graph.get_outedges(v)))
bfs_spantree.append(prev_v, w, v)
return bfs_spantree
def BFS_graph(graph, v0):
vertex_num = graph.get_ver_num()
bfs_seq = [v0]
visited = [0] * vertex_num
visited[v0] = 1
qu = SQueue()
qu.enqueue(graph.get_outedges(v0))
while not qu.is_empty():
edges = qu.dequeue()
for i in range(len(edges)):
v = edges[i][0]
if not visited[v]:
qu.enqueue(graph.get_outedges(v))
visited[v] = 1
bfs_seq.append(v)
return bfs_seq
surface.print_surface(*pos, 'D')
surface.print_surface()
async def run(squeue: 'Queue[KeyboardEvent]'):
_input = Queue()
_output = Queue()
c = Computer(code)
c_execution = asyncio.create_task(c.run(_input, _output))
d_execution = asyncio.create_task(droid(squeue, _input, _output))
await asyncio.wait([c_execution, d_execution], return_when=FIRST_COMPLETED)
if __name__ == '__main__':
keyboard_queue = SQueue()
def queue_keyboardevent(e):
keyboard_queue.put(e)
keyboard.hook_key('w', queue_keyboardevent)
keyboard.hook_key('a', queue_keyboardevent)
keyboard.hook_key('s', queue_keyboardevent)
keyboard.hook_key('d', queue_keyboardevent)
keyboard.hook_key('x', queue_keyboardevent)
asyncio.run(run(keyboard_queue))
class Customs:
def __init__(self, gate_num, duration, arrive_interval, check_interval):
self.simulation = Simulation(duration)
self.waitline = SQueue()
self.duration = duration
self.gates = [0] * gate_num
self.total_wait_time = 0
self.total_used_time = 0
self.car_num = 0
self.arrive_interval = arrive_interval
self.check_interval = check_interval
def wait_time_acc(self, n):
self.total_wait_time += n
def total_time_acc(self, n):
self.total_used_time += n
def car_count_1(self):
self.car_num += 1
def add_event(self, event):
self.simulation.add_event(event)
def cur_time(self):
return self.simulation.cur_time()
def enqueue(self, car):
self.waitline.enqueue(car)
def has_queued_car(self):
return not self.waitline.is_empty()
def next_car(self):
return self.waitline.dequeue()
def find_gate(self):
for i in range(len(self.gates)):
if self.gates[i] == 0:
self.gates[i] = 1
return i
return None
def free_gate(self, i):
if self.gates[i] == 1:
self.gates[i] == 0
else:
raise ValueError('Clear gate Error.')
def simulate(self):
Arrive(0, self)
self.simulation.run()
self.statistics()
def statistics(self):
print("Simulate " + str(self.duration) + " minutes, for " + str(len(self.gates)) + " gates")
print(self.car_num, "cars pass the customs")
print("Average waiting time:", self.total_wait_time / self.car_num)
print("Average passing time:", self.total_used_time / self.car_num)
i = 0
while not self.waitline.is_empty():
self.waitline.dequeue()
i += 1
print(i, "cars are in waiting line.")