def tune(self) :
'''
决策树剪枝函数,采取的是自底向上依次剪枝.剪枝规则,寻找T_{k+1} , s.t. minimize(l(T_{k+1}) - l(T_k)).
根据定理,子树是严格嵌套的,因此可以根据非叶子节点的个数进行枚举,每次用BFS遍历决策树,计算剪枝后的loss差值,
取最小的作为答案加入队列.
'''
self.trees.append(self.tree)
for step in range(self.tree.n_node) :
temp_tree = copy.deepcopy(self.trees[-1])
best_loss = None
best_node = None
tree_queue = Queue(maxsize = 0)
tree_queue.push(temp_tree.tree)
while (tree_queue.empty() != False) :
now_node = tree_queue.get()
if (now_node.is_leaf == True) :
continue
if (best_loss == None or now_node.loss_before_split < best_loss) :
best_loss = now_node.loss_before_split
best_node = now_node
if (now_node.left != None) :
tree_queue.put(now_node.left)
if (now_node.right != None) :
tree_queue.put(now_node.right)
best_node.is_leaf = True
self.trees.append(temp_tree)
return self
def reverse(self):
"""
Flips all edges in the graph.
:return: The reversed graph.
"""
if not self._directed:
return self.duplicate()
rev_G = Graph(self._directed, self._weighted)
V = deepcopy(self.get_vertices())
visited = set([])
for v in V:
queue = Queue()
queue.push(v)
while not queue.empty():
curr = queue.pop()
if curr in visited:
continue
visited.add(curr)
neighbors = self.get_neighbors(curr)
for neighbor in neighbors:
queue.push(neighbor)
edge_value = None if not self._weighted else self._edge_values[
(curr, neighbor)]
rev_G.add_edge(neighbor, curr, edge_value)
if len(neighbors) == 0:
rev_G.add_vertex(curr)
return rev_G
def findNearest(env, start, targ, rng=4 ):
#Quick check
rs, ts = start
if not inRange(env, start, targ, rng):
return
#Expensive search
cur = Queue()
visited = {}
cur.push(start)
while not cur.empty:
r, c = cur.pop()
if (r, c) in visited:
continue
if env[r, c] == targ:
return (r, c)
visited[(r, c)] = 1
if rs - r < targ:
cur.push(r+1, c)
if cs - c < targ:
cur.push(r, c+1)
if r - rs < targ:
cur.push(r-1, c)
if c - cs < targ:
cur.push(r, c-1)
return None
def duplicate(self):
"""
Creates a copy of the graph.
:return: The duplicated graph.
"""
new_G = Graph(self._directed, self._weighted)
if self.empty():
return new_G
V = deepcopy(self.get_vertices())
visited = set([])
for v in V:
queue = Queue()
queue.push(v)
while not queue.empty():
curr = queue.pop()
if curr in visited:
continue
visited.add(curr)
neighbors = self.get_neighbors(curr)
for neighbor in neighbors:
queue.push(neighbor)
edge_value = None if not self._weighted else self._edge_values[
(curr, neighbor)]
new_G.add_edge(curr, neighbor, edge_value)
if len(neighbors) == 0:
new_G.add_vertex(curr)
return new_G
def bfs(self, v):
"""
Performs a breadth-first-search of the graph starting with
the vertex v. Assumes that v is in the graph.
:param v: Starting vertex of the graph.
:return: A list of the verticies traveled.
"""
assert self.has_vertex(v)
vertices_traversed = []
vertices = self.get_vertices()
visited = set([])
queue = Queue()
queue.push(v)
while not queue.empty():
curr = queue.pop()
if curr in visited:
continue
visited.add(curr)
vertices_traversed.append(curr)
neighbors = list(self.get_neighbors(curr))
random.shuffle(neighbors)
for neighbor in neighbors:
queue.push(neighbor)
return vertices_traversed
def bfs():
s = input("enter start node")
e = input("enter end node")
start = g.getVertex(s)
end = g.getVertex(e)
if not start:
print(f"{s} not in graph")
return
if not end:
print(f"{e} not in graph")
return
Q = Queue()
start.discovered = True
Q.push(start)
while not Q.isEmpty():
current = Q.pop()
if current.id == end.id:
break
for neighbour in current.connectedTo:
if not neighbour.discovered:
neighbour.discovered = True
neighbour.parent = current
Q.push(neighbour)
curr = end
while curr.parent is not None:
if curr.id.isupper():
print(f"was in {curr.id} with")
else:
print(f"{curr.id}")
curr = curr.parent
print(start.id)
def isShuffle(str1, str2, str3):
A = Queue() # First in, first out (FIFO queue)
B = Queue()
for i in range(len(str1)-1, 0):
A.push(str1[i])
for j in range(len(str2)-1, 0):
B.push(str1[i])
for c in str3:
if c in A:
# non supported operation in Python for queues: we can do:
# while A.size()>0, A.pop(), but it is too late once popped if
# the letter is not the one we are processing in word c.
# We use lists instead and increment indexes accordingly.
if not c == A.pop():
if not c == B.pop():
return False
elif c in B:
if not c == B.pop():
if not c == A.pop():
return False
else:
return False
def test_push_multiple_messages(self,
get_queue_mock,
message_mock):
"""
Notice the decoration and parameter order: the first
parameter is the closest to the function name (thing how
decorator are called).
write called as many times as number of messages
"""
queueName = "TestQueue"
message1 = "TestMessage1"
message2 = "TestMessage2"
queue_mock = Mock()
get_queue_mock.return_value = queue_mock
envelope_mock = Mock()
message_mock.return_value = envelope_mock
queue = Queue(queueName)
queue.push(message1, message2)
self.assertEqual(queue_mock.write.call_count, 2)
envelope_mock.set_body.assert_any_call(message1)
envelope_mock.set_body.assert_called_with(message2)
def bfs(node): q = Queue() q.push(node) while not q.is_empty(): n = q.pop() print(n.data) for cn in n.nodes: q.push(cn)
def test_isEmpty_when_non_empty_queue(self):
# Arrange
queue = Queue()
queue.push("Umair")
# Act
# Assert
self.assertFalse(queue.isEmpty())
def test_basics():
q = Queue()
for i in range(10):
q.push(i)
items = list(reversed(range(10)))
while(q.peek() != None):
assert q.pop() == items.pop()
def test_push_when_empty_queue(self):
# Arrange
queue = Queue()
# Act
queue.push("Umair")
# Assert
self.assertEqual("Umair", queue.pop())
def test_top_when_non_empty_queue(self):
# Arrange
queue = Queue()
queue.push("Umair")
queue.push("Aamir")
queue.push("Usman")
# Act
# Assert
self.assertEqual("Umair", queue.top())
def isPalindrome(word):
forward = Queue()
backward = Stack()
for letter in word:
forward.push(letter)
backward.push(letter)
for i in range(forward.size()):
if forward.pop() != backward.pop():
return False
return True
def test_size_when_non_empty_queue(self):
# Arrange
queue = Queue()
queue.push("Umair")
# Act
size = queue.size()
# Assert
self.assertEqual(1, size)
def pop(self):
q = Queue()
while self.values.size > 1:
q.push(self.values.pop())
last_element = self.values.pop()
while q.size > 0:
self.values.push(q.pop())
return last_element
def test_push_pop_single_element(self):
# Arrange
q = Queue()
# Act
q.push('a')
# Assert
self.assertEqual(1, len(q))
self.assertEqual('a', q.pop())
self.assertEqual(0, len(q))
def propagate_wavefront_bfs(self):
self.__logger.log('###### running BFS ######')
wavefront = Queue()
wavefront.push(self.__goal_coordinates)
is_goal_found = self.__bfs_update(wavefront)
self.__logger.log('###### BFS results ######')
if not is_goal_found:
self.__logger.log("start can't be reached")
self.__logger.log('nodes= {nodes}, updates= {updates}'.format(
nodes=self.__node_counter, updates=self.__update_counter))
self.__logger.log('###### BFS end ######')
def breath_first_search(self, node):
queue = Queue()
if not node:
return None
queue.push(node)
self.is_visited = True
while not queue.is_empty():
popped_node = queue.pop()
print(popped_node.data)
for child_node in popped_node.nodes:
if child_node.is_visited == False:
child_node.is_visited = True
queue.push(child_node)
def test_push_pop_three_element(self):
# Arrange
q = Queue()
# Act
q.push('a')
q.push('b')
q.push('c')
# Assert
self.assertEqual(3, len(q))
self.assertEqual('a', q.pop())
self.assertEqual(2, len(q))
class SortestPath:
def __init__(self, node=[], edges=[]):
self.nodes = {}
self.processed = {}
self.totalSortestPaths = {}
self.sortestLength = 99999999999
self.queue = None
for i in node:
self.nodes[i] = []
for e in edges:
self.nodes[e[0]].append(e[1])
self.nodes[e[1]].append(e[0])
def doBFS(self, node):
num = self.processed[node]
crrNum = num+1
nodes = self.nodes[node]
for n in nodes:
if n == self.target:
if crrNum<self.sortestLength:
self.sortestLength = crrNum
try:
self.totalSortestPaths[crrNum]+=1
except:
self.totalSortestPaths[crrNum] = 1
else:
try:
self.processed[n]
except:
self.processed[n] = crrNum
self.qu.push(n)
while True:
node = self.qu.pop()
print("node: ", node)
if not node:
break
self.doBFS(node)
def sortestPathLengthAndTotalNumber(self, points):
self.processed = {}
self.target = points[1]
self.totalSortestPaths = {}
self.sortestLength = 99999999999
self.qu = Queue()
self.qu.push(points[0])
self.processed[points[0]] = 0
node = self.qu.pop()
self.doBFS(node)
print("sortestLength: ", self.sortestLength)
print("totalSortestPaths: ", self.totalSortestPaths)
def parse_text(self, text):
input_queue = Queue()
number_pattern = '^[0123456789.]+'
function_pattern = '|'.join(['^' + func for func in self.functions])
operation_pattern = '|'.join(['^' + op for op in self.operators])
parantheses_pattern = r'^\(|^\)'
text = text.replace(' ', '').upper()
while len(text) != 0:
if re.search(number_pattern, text) != None:
input_queue.push(
float(re.search(number_pattern, text).group(0)))
text = text[re.search(number_pattern, text).end(0):]
if re.search(function_pattern, text) != None:
input_queue.push(self.functions[re.search(
function_pattern, text).group(0)])
text = text[re.search(function_pattern, text).end(0):]
if re.search(operation_pattern, text) != None:
input_queue.push(self.operators[re.search(
operation_pattern, text).group(0)])
text = text[re.search(operation_pattern, text).end(0):]
if re.search(parantheses_pattern, text) != None:
input_queue.push(re.search(parantheses_pattern, text))
text = text[re.search(parantheses_pattern, text).end(0):]
return input_queue
class Stack(object):
def __init__(self):
self.myQueue = Queue()
self.mySize = 0
def push(self, value):
self.myQueue.push(value)
self.mySize = self.mySize + 1
def size(self):
return self.mySize
def peek(self):
last = None
while True:
popped = self.myQueue.peek()
if not popped:
break
last = popped
return last
def pop(self):
last = None
newQueue = Queue()
poppedFromQueue = 0
queueSize = self.myQueue.size()
while True:
popped = self.myQueue.pop()
if poppedFromQueue != queueSize:
newQueue.push(popped)
poppedFromQueue += 1
if not popped:
break
last = popped
self.mySize = self.mySize - 1
self.myQueue = newQueue
return last
def bfs(source_vertex, vertices, edges):
queue = Queue()
queue.push(source_vertex)
source_vertex.visited = True
source_vertex.dist = 0
while not queue.is_empty():
vertex = queue.pop()
print(vertex.id, vertex.dist)
for dest_vertex in edges[vertex]:
if dest_vertex.visited == False:
queue.push(dest_vertex)
dest_vertex.visited = True
dest_vertex.dist = vertex.dist + 1
def BFS(G, source):
Q = Queue(1000)
Q.push(source)
G.visited[source] = 1
G.dist[source] = 0
#print("BFS traversal: ", end = " ")
while (Q.isEmpty() is False):
t = Q.peek()
print(t, end=" ")
Q.pop()
for i in G.adjList[t]:
if G.visited[i] == 0:
Q.push(i)
G.visited[i] = 1
G.dist[i] = G.dist[t] + 1
print()
def bfs(gr,start):
# se existir start
queue = Queue(7)
print(gr.num)
queue.push(start)
gr.num[start] = gr.count
gr.count+=1
while not queue.isEmpty():
elem = queue.pop()
print(elem)
allV = gr.graph[elem]
for i in allV:
if gr.num[i] == -1:
gr.num[i] = gr.count
gr.count+=1
queue.push(i)
class TabooList:
def __init__(self, size):
self._size = size
self._queue = Queue(size)
self._length = 0
def addMovement(self, movement):
if self._queue.isFull():
self._queue.pop()
self._queue.push(movement)
def __len__(self):
return len(self._queue)
def __str__(self):
return str(self._queue)
def solve_board(board):
'''Checks the current board and compares it to the perfect board.
It then runs a while loop and the "create_children" until the current board matches the goal board.'''
# show initial board configuration
show_board(board)
if not is_possible(board):
print("Bro, not cool. Enter a valid board next time.")
return
q = Queue()
q.put(BoardState(board, None))
goal_state = [
[1,2,3],
[4,5,6],
[7,8,0],
]
visited = Queue()
while True:
current = q.push()
visited.put(current)
if current.board == goal_state:
print('Board solved successfully!!')
show_board(current.board)
return
a = create_children(current)
for x in a:
if q.instances(x) == 0 and visited.instances(x) == 0:
q.put(x)
elif q.instances(x) != 0:
q[0].stepcost = 0
def test():
stack = Stack()
queue = Queue()
items = ["Item 1", "Item 2", "Item 3", "Item 4"]
for item in items:
stack.push(item)
queue.push(item)
print("------------------ Queue test -------------------")
while queue.size() > 0:
print(queue.pop())
print(f"Items left: {queue.size()}")
print("")
print("------------------ Stack test -------------------")
while stack.size() > 0:
print(stack.pop())
print(f"Items left: {stack.size()}")
def shortest_path(graph, start_vertex, end_vertex):
marked_vertices = np.zeros(len(graph.vertices))
distances = np.zeros(len(graph.vertices))
queue = Queue()
marked_vertices[start_vertex - 1] = 1
queue.push(start_vertex)
while not queue.is_empty():
removed_vertex = queue.pop()
for edge in graph.graph_dict[str(removed_vertex)]:
if marked_vertices[edge - 1] != 1:
marked_vertices[edge - 1] = 1
distances[edge - 1] += distances[removed_vertex - 1] + 1
queue.push(edge)
return int(distances[end_vertex - 1] - distances[start_vertex - 1])
def dist(c, rede):
n = len(rede)
# inicia queue
q = Queue()
q.push(c)
# inicia dist
d = [n] * n
d[c] = 0
while not q.vazio():
i = q.dd()
for j in range(n):
if rede[i][j] == 1 and d[j] > d[i]+1:
d[j] = d[i]+1
q.push(j)
return d
class AnimalShelterQueue(object):
def __init__(self):
self.dogs = Queue()
self.cats = Queue()
self.count = 0
def enqueueDog(self, dog):
self.dogs.push((dog, self.count))
self.count += 1
return self
def enqueueCat(self, cat):
self.cats.push((cat, self.count))
self.count += 1
return self
def dequeueAny(self):
if self.dogs.isEmpty() and self.cats.isEmpty():
raise Exception("No animals in queue")
if self.dogs.isEmpty():
aqueue = self.cats
elif self.cats.isEmpty():
aqueue = self.dogs
else:
dog, dc = self.dogs.peek()
cat, cc = self.cats.peek()
if dc < cc:
aqueue = self.dogs
else:
aqueue = self.cats
return aqueue.pop()[0]
def dequeueDog(self):
if self.dogs.isEmpty():
raise Exception("No dogs in queue")
return self.dogs.pop()[0]
def dequeueCat(self):
if self.cats.isEmpty():
raise Exception("No cats in queue")
return self.cats.pop()[0]
def extract_rules(self, tree):
tree_rules = []
tree = ptn.parse(tree)
queue = Queue()
queue.push(tree)
i = 0
while not queue.empty():
t = queue.pop()
rule = Rule(t.node_type, [])
for child in t.children:
queue.push(child)
rule.add_child(child.node_type)
tree_rules.append(rule)
if None in tree_rules:
raw_input('>>>')
return np.array(tree_rules)
def test_part_6():
calc = Calculator()
input_queue = Queue()
list1 = [
calc.functions['EXP'], '(', 1, calc.operators['ADD'], 2,
calc.operators['MULTIPLY'], 3, ')'
]
for elem in list1:
input_queue.push(elem)
output_queue = calc.shunting_yard(input_queue)
# print(output_queue)
for i in range(output_queue.size()):
elem = output_queue.pop()
print(elem)
calc.output_queue.push(elem)
# print(calc2.output_queue)
print("test parser", calc.rpn(False))
def breadth_first_search(graph, started_vertex=None):
marked_vertecies = np.zeros(len(graph.vertices()))
traversed_vertecies = []
queue = Queue()
if started_vertex == None:
started_vertex = random.choice(graph.vertices())
started_vertex = int(started_vertex)
marked_vertecies[started_vertex - 1] = 1
queue.push(started_vertex)
traversed_vertecies.append(started_vertex)
while not queue.is_empty():
removed_vertex = queue.pop()
for edge in graph.graph_dict[str(removed_vertex)]:
if marked_vertecies[edge - 1] != 1:
marked_vertecies[edge - 1] = 1
traversed_vertecies.append(edge)
queue.push(edge)
return traversed_vertecies
def test_front(self):
q = Queue()
q.push(1)
self.assertEqual(q.front(), 1)
q.push(1)
self.assertEqual(q.front(), 1)
q.pop()
q.pop()
q.push(2)
self.assertEqual(q.front(), 2)
