def generate_maze(algorithm, height, width, path, displayMaze):
if algorithm == "backtracking":
backtracking = Backtracking(height, width, path, displayMaze)
backtracking.createMaze()
elif algorithm == "aldous_broder":
aldous_broder = Aldous_Broder(height, width, path, displayMaze)
aldous_broder.createMaze()
elif algorithm == "hunt_and_kill":
hunt_and_kill = Hunt_and_Kill(height, width, path, displayMaze)
hunt_and_kill.createMaze()
elif algorithm == "prims":
prims = Prims(height, width, path, displayMaze)
prims.createMaze()
def main():
# grab word length
i = int(sys.argv[1][0])
# start timer
start = time.time()
# Get relevant words
frontLetters, endLetters, words = extractLetters(i)
wordCount = len(words)
#DFS = DepthFirstSearch(words, wordCount)
#solution = DFS.run()
BT = Backtracking(frontLetters, endLetters, words, wordCount)
solution = BT.search()
end = time.time()
print("Time: ", end-start)
def setUp(self):
self.easy = "003020600900305001001806400008102900700000008006708200" + \
"002609500800203009005010300"
self.normal = "400000805030000000000700000020000060000080400000010000" + \
"000603070500200000104000000"
self.hard = "000006000059000008200008000045000000003000000006003054" + \
"000325006000000000000000000"
self.back = Backtracking()
class TestBacktracking(unittest.TestCase):
def setUp(self):
self.easy = "003020600900305001001806400008102900700000008006708200" + \
"002609500800203009005010300"
self.normal = "400000805030000000000700000020000060000080400000010000" + \
"000603070500200000104000000"
self.hard = "000006000059000008200008000045000000003000000006003054" + \
"000325006000000000000000000"
self.back = Backtracking()
def test_verify_solution_for_easy_grid(self):
expected_result_easy = '48392165796734582125187649354813297672956413' \
'8136798245372689514814253769695417382'
dict_result = self.back.solve(self.easy)
result = self.back.dict_to_string(dict_result)
self.assertEqual(expected_result_easy, result)
def test_verify_solution_for_normal_grid(self):
expected_result_normal = '41736982563215894795872431682543716979158643' \
'2346912758289643571573291684164875293'
dict_result = self.back.solve(self.normal)
result = self.back.dict_to_string(dict_result)
self.assertEqual(expected_result_normal, result)
def test_verify_solution_for_hard_grid(self):
expected_result_hard = "73815624965943217821479863584567931292354186717" \
"6283954481325796562917483397864521"
dict_result = self.back.solve(self.hard)
result = self.back.dict_to_string(dict_result)
self.assertEqual(expected_result_hard, result)
# Created by Ningxiang He, 01/30/2019
from map_color import map_color
from backtracking import Backtracking
import timeit
new_csp = map_color() # create a csp map_color
search = Backtracking(True, True, True)
# define a class Backtracking.
# First parameter represents enable or disable Inference. True means enable. False means disable.
# Second parameter represents enable or disable MRV.
# Third parameter represents enable or disable LCV.
start_time = timeit.default_timer() # start the timer
solution = search.Backtracking_search(new_csp) # call Backtracking search function. Input csp
stop_time = timeit.default_timer() # stop the timer
print ("Run time is:\n", stop_time-start_time) # output run time
print ("The solution is:\n", solution) # print assignment
new_csp.show_result(solution) # print territory and color
def __test_backtracking(self, data):
sudoku = Sudoku(data.puzzle)
Backtracking(sudoku).solve()
self.assertTrue(self.__are_arrays_equal(data.solution, sudoku.cells))
if not config.value_selection:
print('Algoritmo de seleção de valor não especificado')
sys.exit(1)
if not config.look_ahead:
print('Algoritmo de inferencia não especificado')
sys.exit(1)
instances = read_file(config.input_file)
if config.instance_id > 0:
instances = [instances[config.instance_id - 1]]
for variables, domains, constraints, assignment, D, r, n in instances:
try:
bt = Backtracking(variables, domains, constraints, 1000000)
bt.set_is_complete(total_assignment)
bt.set_variable_selection(config.variable_selection)
bt.set_value_selection(config.value_selection)
bt.set_look_ahead(config.look_ahead)
# initial_nassigns = len(assignment)
start = time()
output = bt.solve(assignment)
t = time() - start
# final_nassigns = len(output)
nassigns = bt.csp.nassigns
# print(initial_nassigns, final_nassigns,final_nassigns - initial_nassigns != nassigns)
except KeyboardInterrupt:
t = 0
# Created by Ningxiang He, 01/30/2019
from Circuit_board import Circuit_board
from backtracking import Backtracking
import timeit
cur_csp = Circuit_board() # create a csp circuit board
search = Backtracking(False, True, False)
# define a class Backtracking.
# First parameter represents enable or disable Inference. True means enable. False means disable.
# Second parameter represents enable or disable MRV.
# Third parameter represents enable or disable LCV.
start_time = timeit.default_timer() # start the timer
solution = search.Backtracking_search(
cur_csp) # call Backtracking search function. Input csp
stop_time = timeit.default_timer() # stop the timer
print("Run time is:\n", stop_time - start_time) # print run time
print("The assignment is:\n", solution) # print assignment
cur_csp.show_result(solution) # print the board
def backtrack_time(self, index, iter):
BacktrackingAlgorithm = Backtracking(index, self.SymmetricalMatrix)
start = timer()
BacktrackingAlgorithm.tsp(0, 1, 0)
end = timer()
self.BacktrackingTime[iter] = end - start
def test_backtracking():
backtracking = Backtracking(201, 201, "maze.png", False)
assert backtracking.createMaze() == 0
