def bfsreduceall(sudokuObject):
source = sudokuObject.solutiondriverNoGuess()
if source == "Bad Response":
return None
elif type(source) is Sudoku:
return source
Q = Queue([sudokuObject])
loop = 1
startminnodes = None
while not Q.isempty():
# print("loop no",loop)
if loop > 2: return dfsreduceall(sudokuObject)
# if startminnodes is not None:
# for node in startminnodes:print(node.allowedset,node.id)
# print("Q.unqueue()",Q)
v = Q.unqueue()
unfnodes = v.getOrderedMinnodesUnfilled() # unfinished nodes
if loop == 1: startminnodes = unfnodes
for minnode in unfnodes:
for permutedvalue in minnode.allowedset:
global numsudokuobjects
numsudokuobjects += 1
newsudokuObject = sudokuObject.__deepcopy__()
newsudokuObject.nodes[minnode.id].setValue(permutedvalue)
postsolveobject = newsudokuObject.solutiondriverNoGuess()
if type(postsolveobject) is Sudoku:
return postsolveobject
elif postsolveobject != "Bad Response":
Q.enqueue(newsudokuObject)
loop += 1
return None
def bfs(graph, start):
'''
Using Breadth First Search to traverse Graph.
Method: iterative
Parameter
---------
graph: (dictionary of list)
A dictionary of list on which we are going to apply bfs
start: (key of dictionary)
The element from which we are starting the traverse
Returns
-------
(list) List of points in traverse order
'''
queue = Queue(start)
result = []
result.append(start)
while not queue.isempty():
point = queue.dequeue()
for i in graph[point]:
if i in result:
continue
queue.enqueue(i)
result.append(i)
return result
def minimum(self, root):
if root is None:
return None
sum_queue = Queue()
sum_queue.put(root)
min_level = 0
min_sum = sys.maxsize
current_level = 0
while not sum_queue.isempty():
current_sum = 0
for i in range(2**current_level):
node = sum_queue.pop()
if node.left is not None and node.right is not None:
sum_queue.put(node.left)
sum_queue.put(node.right)
current_sum += node.value
if current_sum < min_sum:
min_sum = current_sum
min_level = current_level
current_level += 1
return min_level
def test_isempty_put_get(self):
q = Queue()
q.put(3)
q.put(1)
q.get()
self.assertEqual(False, q.isempty())
self.assertEqual(q.items, [3])
self.assertEqual(q.size(), 1)
def shortest_path_unweighted_graph_adjacency_matrix(graph, start_v, end_v):
"""
:param graph:
:param start_v: string 'a'
:param end_v: string 'h'
:return: distance, previous_vertex, visited_order
"""
def to_do_vertex(graph, vertex_index):
visited_order.append(graph.vertices[vertex_index])
print('visited vertex: %s' % graph.vertices[vertex_index])
visited = [False] * g.num_vertices
visited_order = []
my_queue = Queue()
# the distance from start vertex to current vertex
distance = [0] * graph.num_vertices
# the previous vertex that come to current vertex
previous_vertex = [None] * graph.num_vertices
current_vertex_index = graph.vertices.index(start_v)
# set the start vertex distance as 0
distance[current_vertex_index] = 0
# marked with visited
visited[current_vertex_index] = True
# deal with the vertex
to_do_vertex(graph, current_vertex_index)
# push stack
my_queue.enqueue(current_vertex_index)
while not my_queue.isempty():
# pop the first element as current vertex
current_vertex_index = my_queue.dequeue()
# find all the adjacent vertices
for i in range(graph.num_vertices):
if (0 < graph.matrix[current_vertex_index][i] < inf) and not visited[i]:
# calculate the distance
distance[i] = distance[current_vertex_index] + 1
# mark the previous
previous_vertex[i] = current_vertex_index
# deal with the vertex
to_do_vertex(graph, i)
# mark the vertex
visited[i] = True
# check whether come to the end
if graph.vertices[i] is end_v:
print('find the path from %s to %s' % (start_v, end_v))
return distance, previous_vertex, visited_order
# enqueue the element
my_queue.enqueue(i)
print('can not find the path from %s to %s' % (start_v, end_v))
return False
def BFS(mygraph,source,group = None):
mygraph.nodes[source].explored = True
mygraph.nodes[source].layer = 0
mygraph.nodes[source].group = group
Q = Queue([source])
while Q.isempty() == False:
v = Q.unqueue()
for secondnode in mygraph.graph_dict[v]:
if mygraph.nodes[secondnode].explored == False:
mygraph.nodes[secondnode].explored = True
mygraph.nodes[secondnode].layer = mygraph.nodes[v].layer + 1
mygraph.nodes[secondnode].group = group
Q.enqueue(secondnode)
return mygraph
def get_sequence_continuations(game, node):
"""
Inputs: game::GameTree
Want to put sequences on the information sets to which they correspond
"""
if game is None:
raise InvalidInputException("Input is None")
if game.tree.isEmpty():
return []
t = game.tree
root = t.root()
# To output:
sequences = [[]]
Q = Queue()
qlist = []
while not Q.isempty():
node = Q.get()
from queue import Queue
q = Queue(5)
q.enqueue('a')
print(q)
print(q.isempty())
print(q.isfull())
chars = ['b', 'c', 'd']
for el in chars:
q.enqueue(el)
print(q.display())
print(q.dequeue())
for _ in range(10):
buckets.append(Queue())
#print(buckets)
m = 200 #number of numbers
n = 5 #highest number will be 10**n
orignalSeq = []
for _ in range(m):
number = random.randint(0, 10**n-1)
orignalSeq.append(number)
queue.put(number)
print("Vi börjar med ordningen:", orignalSeq)
for i in range(0, n):
#1
while not queue.isempty():
x = queue.get()
#print("queue.get ger", x)
y = int(x / 10**i)
k = y % 10
buckets[k].put(x)
#2
for bucket in buckets:
while not bucket.isempty():
x = bucket.get()
queue.put(x)
finalSeq = []
while not queue.isempty():
finalSeq.append(queue.get())
if svenska.exists(child) and not gamla.exists(child):
nod2=Node(child, nod) #skapar vi en ny nod med child som ord(value) och pekar(parent) på nod
gamla.put(child) #stoppar in de besökta child i binärträdet gamla
q.put(nod2) #stoppar in nod2 i kön
def countchain(nod2):
if nod2.parent==None:
return 0
else:
return 1+countchain(nod2.parent)
def writechain(nod2):
if nod2.parent==None:
print(nod2.value)
return
writechain(nod2.parent)
print(nod2.value)
q.put(Node(startord,None)) #stoppar in startord i kön
while not q.isempty(): #så länge kön inte är tom...
word=q.get() #Lagrar q.get() som en variabel
makesons(word) #Kör makesons på alla ord man stoppar in i kön, dvs sönerna till starordet och sönernas söner osv. Tills man ej hittar några söner längre. Det sista ordet som man då tog ut i kön är det ordet som ger den längsta vägen till gud.
writechain(word) #När kön är tom så skriver man ut längsta kedjan till/från gud.
print("Kedjans längd:", countchain(word)) #Skriver ut längsta kedjans längd.
def test_isempty_put1_get1(self):
q = Queue()
q.put(10)
q.get()
self.assertEqual(True, q.isempty())
print('queue is empty after 1 put & 1 get items')
) #skapar vi en ny nod med child som ord(value) och pekar(parent) på nod
gamla.put(
child) #stoppar in de besökta child i binärträdet gamla
q.put(nod2) #stoppar in nod2 i kön
def countchain(nod2):
if nod2.parent == None:
return 0
else:
return 1 + countchain(nod2.parent)
def writechain(nod2):
if nod2.parent == None:
print(nod2.value)
return
writechain(nod2.parent)
print(nod2.value)
q.put(Node(startord, None)) #stoppar in startord i kön
while not q.isempty(): #så länge kön inte är tom...
word = q.get() #Lagrar q.get() som en variabel
makesons(
word
) #Kör makesons på alla ord man stoppar in i kön, dvs sönerna till starordet och sönernas söner osv. Tills man ej hittar några söner längre. Det sista ordet som man då tog ut i kön är det ordet som ger den längsta vägen till gud.
writechain(
word) #När kön är tom så skriver man ut längsta kedjan till/från gud.
print("Kedjans längd:", countchain(word)) #Skriver ut längsta kedjans längd.
