def mergeKLists(self, lists):
"""
:type lists: List[ListNode]
:rtype: ListNode
"""
if not lists:
return None
st = PriorityQueue()
for x in lists:
if x:
st.push(x, x.val)
if st.size() == 0:
return None
head = tail = None
while st.size() != 0:
ptr = st.pop()
if ptr.next:
st.push(ptr.next, ptr.next.val)
ptr.next = None
if ptr == None:
continue
if tail == None:
head = ptr
else:
tail.next = ptr
tail = ptr
tail.next = None
return head
def best_first_search(problem, f):
"Search nodes with minimum f(node) value first."
frontier = PriorityQueue([Node.Node(problem.initial)], key=f)
reached = {}
while frontier:
node = frontier.pop()
if problem.is_goal(node.state):
return node, len(frontier)
for child in Node.expand(problem, node):
s = child.state
if s not in reached or child.path_cost < reached[s].path_cost:
reached[s] = child
frontier.add(child)
return failure, None
def mergeKLists(self, lists): """ :type lists: List[ListNode] :rtype: ListNode """ pq = PriorityQueue() dummy = ListNode(0) curr = dummy for node in lists: if node: pq.add((curr, curr.val)) while pq: node = pq.pop() curr.next = ListNode(node.val) curr = curr.next pq.add((node.next, node.next.val))
def djikstra(start,end,edge_weight):
path_weight = {node: float('inf') if node != start else 0 for node in adj_list}
previous = {node: None for node in adj_list}
pqueue = PriorityQueue()
pqueue.put((0,start))
while not pqueue.empty():
node = pqueue.pop()[1]
for child in node.children:
if path_weight[node] + edge_weight[(node,child)] < path_weight[child]:
path_weight[child] = path_weight[node] + edge_weight[(node,child)]
# TODO update pqueue path_weight of child
try:
pqueue.get(child)
except:
# do nothing
pqueue.put((path_weight[child],child))
previous[child] = node
def mergeKLists(self, lists):
"""
:type lists: List[ListNode]
:rtype: ListNode
"""
from Queue import PriorityQueue
if not lists:
return None
pq = PriorityQueue()
for lst in lists:
if lst:
pq.put((lst.val, lst))
dummy = cur = ListNode(None)
while not pq.empty():
v, nd = pq.pop()
cur.next = nd
cur = cur.next
if nd.next:
pq.put((nd.next.val, nd.next))
return dummy.next
class Solver:
def __init__(self):
self.total_iters = 0
self.queue = None
self.visited = None
self.visited_directions = None
self.puzzle_state = None
self.heuristic = None
self.method = None
self.methods = {
'bfs': self.bfs,
'dfs': self.dfs,
'id_dfs': self.id_dfs,
'a_star': self.a_star
}
def search(self, method):
self.reset_puzzle(method)
start = dt.datetime.now()
search_outcome = self.methods[method]()
end = dt.datetime.now()
if self.puzzle_state:
moves = self.puzzle_state.moves
directions = self.puzzle_state.directions if len(self.puzzle_state.directions) < 50 else []
else:
moves = None
directions = None
result = SearchResult(
search_outcome,
self.total_iters,
len(self.queue),
moves,
directions,
end - start
)
return result
def log_state(self):
if self.total_iters % 20000 == 0:
stdout.write(".")
stdout.flush()
def reset_puzzle(self, method):
self.total_iters = 0
self.puzzle_state = BlocksworldPuzzle(setup.generate_puzzle())
self.visited = set()
self.visited_directions = {}
if method == 'bfs':
self.queue = deque([self.puzzle_state])
elif method == 'dfs':
self.queue = [self.puzzle_state]
self.visited = {}
elif method == 'id_dfs':
self.queue = [self.puzzle_state]
self.visited = {}
elif method == 'a_star':
self.queue = PriorityQueue()
self.queue.put((0, self.puzzle_state))
self.heuristic = lambda heur: heur.total_manhattan_distance()
# Breadth-first search.
# FIFO queue -- Double Ended Queue(DEQUEUE)
# GET - left | ADD - right.
def bfs(self):
while len(self.queue) > 0:
self.total_iters += 1
self.log_state()
self.visited_directions = {}
# Get nearest(more shallow state.
self.puzzle_state = self.queue.popleft()
# Add current state to visited ones
self.visited.add(self.puzzle_state.puzzle_hash())
self.visited_directions[self.puzzle_state.puzzle_hash()] = self.puzzle_state.directions
if self.puzzle_state.is_goal_state():
return True
def is_visited(state, visited):
return state.puzzle_hash() in visited
# Queue extend with not visited
valid_children = []
for child_state in self.puzzle_state.get_children():
if not is_visited(child_state, self.visited):
valid_children.append(child_state)
self.queue.extend(valid_children)
# No result.
return False
# Depth First Search.
# Not optimal solution.
# It can go on infinitely.
# LIFO Queue --> python list()
def dfs(self):
self.queue = [self.puzzle_state]
# Visited : {state_hash:state_depth}
self.visited = {}
while len(self.queue) > 0:
# Stopping in 1000000 iterations in case of infinite loop
if self.total_iters > 1000000:
return False
self.total_iters += 1
self.log_state()
# Get the state that is deepest
self.puzzle_state = self.queue.pop() # Get deepest state.
# Add current state in visited.
self.visited[self.puzzle_state.puzzle_hash()] = self.puzzle_state.moves
self.visited_directions[self.puzzle_state.puzzle_hash()] = self.puzzle_state.directions
if self.puzzle_state.is_goal_state():
return True
def is_visited(child, visited):
return child.puzzle_hash() in visited
valid_children = []
for child_state in self.puzzle_state.get_children():
if not is_visited(child_state, self.visited) \
or self.visited[child_state.puzzle_hash()] > child_state.moves:
valid_children.append(child_state)
self.queue.extend(valid_children)
# No result
return False
# Iterative deepening depth-first search.
# The solution is more optimal than DFS.
# It is faster than BFS
# It can go on infinitely, like DFS.
# LIFO Queue --> python list()
def id_dfs(self):
start_state = self.puzzle_state
for depth in itertools.count():
self.queue = [start_state]
self.visited = {}
while len(self.queue) > 0:
self.total_iters += 1
self.log_state()
# Get the state that is the deepest.
self.puzzle_state = self.queue.pop()
# Add current state to visited ones.
self.visited[self.puzzle_state.puzzle_hash()] = self.puzzle_state.moves
self.visited_directions[self.puzzle_state.puzzle_hash()] = self.puzzle_state.directions
if self.puzzle_state.is_goal_state():
return True
def is_visited(child, visited):
return child.puzzle_hash() in visited
if self.puzzle_state.moves < depth:
valid_children = []
for child_state in self.puzzle_state.get_children():
if not is_visited(child_state, self.visited) \
or self.visited[child_state.puzzle_hash()] > child_state.moves:
valid_children.append(child_state)
self.queue.extend(valid_children)
return False
# A* search.
# Most optimal solution time-wise.
# QUEUE: PRIORITY QUEUE(when _get() is used, it gets the item with the minimum value first)
# ORDER: Heuristic(Total Manhattan Distance + number of state moves)
def a_star(self):
# Total_moves = total so far + total to be made
def total_moves(puzzle_state, heuristic):
return puzzle_state.moves + heuristic(self.puzzle_state)
def state_cost_tuple(puzzle_state, heuristic):
return total_moves(puzzle_state, heuristic), puzzle_state
def valid_children(puzzle_state, visited):
children = []
for child_state in puzzle_state.get_children():
if child_state.puzzle_hash() not in visited:
children.append(child_state)
return children
while not self.queue.empty():
self.total_iters += 1
self.log_state()
# Get state with lowest value(moves left)
self.puzzle_state = self.queue.get()[1]
# Add state to visited
self.visited.add(self.puzzle_state.puzzle_hash())
self.visited_directions[self.puzzle_state.puzzle_hash()] = self.puzzle_state.directions
if self.puzzle_state.is_goal_state():
self.queue = self.queue.queue
return True
for valid_child in valid_children(self.puzzle_state, self.visited):
self.queue.put(state_cost_tuple(valid_child, self.heuristic))
# No result
self.queue = self.queue.queue
return False
class Solver:
def __init__(self):
self.total_iters = 0
self.queue = None
self.visited = None
self.visited_directions = None
self.puzzle_state = None
self.heuristic = None
self.method = None
self.methods = {
'bfs': self.bfs,
'dfs': self.dfs,
'id_dfs': self.id_dfs,
'a_star': self.a_star
}
def search(self, method):
self.reset_puzzle(method)
start = dt.datetime.now()
search_outcome = self.methods[method]()
end = dt.datetime.now()
if self.puzzle_state:
moves = self.puzzle_state.moves
directions = self.puzzle_state.directions if len(
self.puzzle_state.directions) < 50 else []
else:
moves = None
directions = None
result = SearchResult(search_outcome, self.total_iters,
len(self.queue), moves, directions, end - start)
return result
def log_state(self):
if self.total_iters % 20000 == 0:
stdout.write(".")
stdout.flush()
def reset_puzzle(self, method):
self.total_iters = 0
self.puzzle_state = BlocksworldPuzzle(setup.generate_puzzle())
self.visited = set()
self.visited_directions = {}
if method == 'bfs':
self.queue = deque([self.puzzle_state])
elif method == 'dfs':
self.queue = [self.puzzle_state]
self.visited = {}
elif method == 'id_dfs':
self.queue = [self.puzzle_state]
self.visited = {}
elif method == 'a_star':
self.queue = PriorityQueue()
self.queue.put((0, self.puzzle_state))
self.heuristic = lambda heur: heur.total_manhattan_distance()
# Breadth-first search.
# FIFO queue -- Double Ended Queue(DEQUEUE)
# GET - left | ADD - right.
def bfs(self):
while len(self.queue) > 0:
self.total_iters += 1
self.log_state()
self.visited_directions = {}
# Get nearest(more shallow state.
self.puzzle_state = self.queue.popleft()
# Add current state to visited ones
self.visited.add(self.puzzle_state.puzzle_hash())
self.visited_directions[
self.puzzle_state.puzzle_hash()] = self.puzzle_state.directions
if self.puzzle_state.is_goal_state():
return True
def is_visited(state, visited):
return state.puzzle_hash() in visited
# Queue extend with not visited
valid_children = []
for child_state in self.puzzle_state.get_children():
if not is_visited(child_state, self.visited):
valid_children.append(child_state)
self.queue.extend(valid_children)
# No result.
return False
# Depth First Search.
# Not optimal solution.
# It can go on infinitely.
# LIFO Queue --> python list()
def dfs(self):
self.queue = [self.puzzle_state]
# Visited : {state_hash:state_depth}
self.visited = {}
while len(self.queue) > 0:
# Stopping in 1000000 iterations in case of infinite loop
if self.total_iters > 1000000:
return False
self.total_iters += 1
self.log_state()
# Get the state that is deepest
self.puzzle_state = self.queue.pop() # Get deepest state.
# Add current state in visited.
self.visited[
self.puzzle_state.puzzle_hash()] = self.puzzle_state.moves
self.visited_directions[
self.puzzle_state.puzzle_hash()] = self.puzzle_state.directions
if self.puzzle_state.is_goal_state():
return True
def is_visited(child, visited):
return child.puzzle_hash() in visited
valid_children = []
for child_state in self.puzzle_state.get_children():
if not is_visited(child_state, self.visited) \
or self.visited[child_state.puzzle_hash()] > child_state.moves:
valid_children.append(child_state)
self.queue.extend(valid_children)
# No result
return False
# Iterative deepening depth-first search.
# The solution is more optimal than DFS.
# It is faster than BFS
# It can go on infinitely, like DFS.
# LIFO Queue --> python list()
def id_dfs(self):
start_state = self.puzzle_state
for depth in itertools.count():
self.queue = [start_state]
self.visited = {}
while len(self.queue) > 0:
self.total_iters += 1
self.log_state()
# Get the state that is the deepest.
self.puzzle_state = self.queue.pop()
# Add current state to visited ones.
self.visited[
self.puzzle_state.puzzle_hash()] = self.puzzle_state.moves
self.visited_directions[self.puzzle_state.puzzle_hash(
)] = self.puzzle_state.directions
if self.puzzle_state.is_goal_state():
return True
def is_visited(child, visited):
return child.puzzle_hash() in visited
if self.puzzle_state.moves < depth:
valid_children = []
for child_state in self.puzzle_state.get_children():
if not is_visited(child_state, self.visited) \
or self.visited[child_state.puzzle_hash()] > child_state.moves:
valid_children.append(child_state)
self.queue.extend(valid_children)
return False
# A* search.
# Most optimal solution time-wise.
# QUEUE: PRIORITY QUEUE(when _get() is used, it gets the item with the minimum value first)
# ORDER: Heuristic(Total Manhattan Distance + number of state moves)
def a_star(self):
# Total_moves = total so far + total to be made
def total_moves(puzzle_state, heuristic):
return puzzle_state.moves + heuristic(self.puzzle_state)
def state_cost_tuple(puzzle_state, heuristic):
return total_moves(puzzle_state, heuristic), puzzle_state
def valid_children(puzzle_state, visited):
children = []
for child_state in puzzle_state.get_children():
if child_state.puzzle_hash() not in visited:
children.append(child_state)
return children
while not self.queue.empty():
self.total_iters += 1
self.log_state()
# Get state with lowest value(moves left)
self.puzzle_state = self.queue.get()[1]
# Add state to visited
self.visited.add(self.puzzle_state.puzzle_hash())
self.visited_directions[
self.puzzle_state.puzzle_hash()] = self.puzzle_state.directions
if self.puzzle_state.is_goal_state():
self.queue = self.queue.queue
return True
for valid_child in valid_children(self.puzzle_state, self.visited):
self.queue.put(state_cost_tuple(valid_child, self.heuristic))
# No result
self.queue = self.queue.queue
return False
b =[5,2,9,4]
a = PriorityQueue()
heapq.heappush(b, 3)
heapq.heapify(b) #once heapify, then the heap will maintain the order forever
print heapq.heappop(b)
print heapq.heappop(b)
heapq.heappush(b,1)
print b[0]
print b[1]
print len(b)
print("*******************")
nums = [1, 8, 2, 23, 7, -4, 18, 23, 42, 37, 2]
print heapq.nlargest(3, nums)
print nums
a = deque([])
a.append(6)
a.append(5)
a.append(4)
print a
print a.pop()
print a.popleft()
print a[0]
print len(a)
class Simulator(object):
def __init__(self,
stats = None,
render = None) :
self.waiting = PriorityQueue()
self.server = Server()
self.active = None
self.events = EventList()
self.clock = 0
self.tasks = []
self.until = 0
# Statistics
if stats is not None:
self.stats = True
self.stats_file = open(stats, "wb")
self.stats_writer = csv.writer(self.stats_file, delimiter='|', lineterminator='\n')
self.write_headers()
else:
self.stats = False
# Rendering
if render is not None:
self.render = True
self.render_file = render
self.render_data = dict()
else:
self.render = False
def update(self):
"""
Update simulator state after any event.
"""
# Which instance to execute ?
self.selectInstance()
# If there is no instance, nothing to do
if self.active is None:
return
else:
# Compute finish event
self.events.put(self.active.event(self.clock))
# Compute server event
self.events.put(self.server.event(self.clock))
def advance(self, time):
"""
Advance the simulator to the given time.
"""
if self.active is not None:
self.active.advance(self.clock, time)
self.server.advance(self.clock, time)
self.clock = time
def selectInstance(self):
"""
Select (set the variables) the instance to execute on the simulator
according to the state of various entities.
"""
if self.server.state != Server.WAITING:
if self.waiting.isEmpty():
self.active = None
else:
self.active = self.waiting.first()
elif self.waiting.isEmpty():
self.active = self.server.activate()
else:
if self.waiting.first().priority > self.server.priority:
self.active = self.waiting.first()
else:
self.active = self.server.activate()
def reactArrival(self, event):
# Put the new instance on its waiting list
if event.instance.type == Instance.SOFT:
self.server.put(event.instance)
elif event.instance.type == Instance.HARD:
self.waiting.put(event.instance, event.instance.priority)
# Compute the next arrival
self.events.put(event.instance.task.nextArrival(event.time))
def reactFinish(self, event):
# Remove the instance from its waiting list
if event.instance.type == Instance.SOFT:
self.server.pop()
elif event.instance.type == Instance.HARD:
self.waiting.pop()
# Compute statistics
if self.stats :
event.instance.statistics()
self.write_instance(event.instance)
# Compute rendering
if self.render :
task = event.instance.task
if not task.id in self.render_data:
self.render_data[task.id] = dict()
self.render_data[task.id]["executed"] = list()
self.render_data[task.id]["arrivals"] = list()
for t in event.instance.executed:
self.render_data[task.id]["executed"].append(t)
self.render_data[task.id]["arrivals"].append(event.instance.arrival)
def reactSuspend(self, event):
# Suspend the server
self.server.suspend()
def reactRefill(self, event):
# Refill the server
self.server.refill()
self.events.put(self.server.nextRefill(event.time))
def read(self, filename):
"""
Load a configuration from a file.
"""
r = ReadConfig()
r.read(filename)
self.server = r.server
self.tasks = r.tasks
def init(self, until = -1):
"""
Initialize the server to run until the given time.
If -1 is given, run until the LCM of periodic tasks.
"""
logging.debug("Initialization until " + str(until))
if (until == -1):
until = PeriodicTask.lcm(self.tasks)
for t in self.tasks:
self.events.put(t.nextArrival(0));
self.events.put(self.server.nextRefill(0))
self.until = until
def run(self):
"""
Execute the simulation.
"""
next = self.events.next()
while next.time < self.until:
self.advance(next.time)
logging.debug(str(self.clock) + ": Event " + next.type + " "
+ (next.instance.task.id
if next.instance is not None else ""))
if next.type == Event.ARRIVAL:
self.reactArrival(next)
elif next.type == Event.FINISH:
self.reactFinish(next)
elif next.type == Event.SUSPEND:
self.reactSuspend(next)
elif next.type == Event.REFILL:
self.reactRefill(next)
self.update()
next = self.events.next()
if self.stats:
self.write_footers()
if self.render:
self.rendering()
def write_headers(self):
"""
Write the results to a file.
"""
col = 6
# Write some comments on the head of the file
width = 9*(col + 1)
self.stats_file.write("Simulator results")
today = date.today()
self.stats_file.write(("Date : " +
str(today.day) + "/" +
str(today.month) + "/" +
str(today.year) + "\n").rjust(width - 17))
self.stats_file.write("\n")
# Write the table headers
self.stats_writer.writerow(["id"[0:col].center(col),
"type"[0:col].center(col),
"arrival"[0:col].center(col),
"start"[0:col].center(col),
"finish"[0:col].center(col),
"computation"[0:col].center(col),
"idle"[0:col].center(col),
"deadline"[0:col].center(col),
"TTD"[0:col].center(col)])
def write_instance(self, instance):
col = 20
self.stats_writer.writerow([instance.task.id[0:col].rjust(col),
instance.type[0:col].rjust(col),
str(instance.arrival)[0:col].rjust(col),
str(instance.start)[0:col].rjust(col),
str(instance.finish)[0:col].rjust(col),
str(instance.computation)[0:col].rjust(col),
str(instance.idle)[0:col].rjust(col),
str(instance.deadline)[0:col].rjust(col),
str(instance.time_to_deadline)[0:col].rjust(col)])
def write_footers(self):
col = 6
width = 9*(col + 1)
self.stats_file.write(("Runtime : " + str(self.clock) + "\n").rjust(width))
self.stats_file.write("Server : " +
str(self.server.__class__.__name__))
self.stats_file.write("\n")
if isinstance(self.server, PollingServer):
self.stats_file.write("Capacity : " +
str(self.server.capacity) +
" Period : " +
str(self.server.period) + "\n")
self.stats_file.close()
def rendering(self):
"""
Render the graph of execution.
"""
plt.clf()
plt.subplot('311')
y_pos = np.arange(len(self.render_data))
i = 0
for key, data in self.render_data.iteritems():
for time in data["executed"]:
plt.barh(i-0.5, time[1] - time[0], left = time[0], height=1.0)
for arrival in data["arrivals"]:
plt.plot(arrival, i, "r+")
i += 1
plt.yticks(y_pos, [key for key in self.render_data])
#print self.server.stats["ctimes"]
plt.subplot('312')
plt.plot(self.server.stats["ctimes"], self.server.stats["cvalues"])
plt.subplot('313')
plt.plot(self.server.stats["itimes"], self.server.stats["ivalues"])
plt.savefig(self.render_file)
