def gc_model_opt(instance, avl_colors): n_nodes, edges = graph_utils.load_instance(instance) solver = pywrapcp.Solver('gc_model_opt') nodes = [solver.IntVar(1, avl_colors) for i in range(n_nodes)] for i in range(len(edges)): solver.Add(nodes[edges[i][0] - 1] != nodes[edges[i][1] - 1]) max_colors = solver.Max(nodes).Var() objective_monitor = solver.Minimize(max_colors, 1) monitors = [] monitors.append(objective_monitor) # impact-based parameters = pywrapcp.DefaultPhaseParameters() parameters.var_selection_schema = parameters.CHOOSE_MAX_AVERAGE_IMPACT parameters.value_selection_schema = parameters.SELECT_MIN_IMPACT db = solver.DefaultPhase(nodes, parameters) # lexicografic # db = solver.Phase(nodes, solver.INT_VAR_DEFAULT, solver.INT_VALUE_DEFAULT) # min domain # db = solver.Phase(nodes, solver.CHOOSE_MIN_SIZE, solver.INT_VALUE_DEFAULT) # random # db = solver.Phase(nodes, solver.CHOOSE_RANDOM, solver.INT_VALUE_DEFAULT) collector = solver.BestValueSolutionCollector(False) # This is a monitor collector.AddObjective(max_colors) collector.Add(nodes) monitors.append(collector) max_time = 1000 * 60 * 10 # 10 Minutes timelimit = solver.TimeLimit(max_time) # This is another monitor monitors.append(timelimit) if solver.Solve(db, monitors): # Visualize the solution # utils.graph_visualization(nodes, collector, edges) text = None if solver.WallTime() < max_time: text = 'Optimal solution: {}. ' + 'Proved after {} ms'.format( solver.WallTime()) else: text = 'Best solution found: {}' print(text.format(collector.ObjectiveValue(0))) print('Solution found after {} ms. {} branches and {} failures'.format( collector.WallTime(0), collector.Branches(0), collector.Failures(0))) graph_utils.graph_visualization(nodes, collector, edges) else: print('Not solved')
def gc_model_unsat(instance, avl_colors): n_nodes, edges = graph_utils.load_instance(instance) solver = pywrapcp.Solver('gc_model_unsat') nodes = [solver.IntVar(1, avl_colors) for i in range(n_nodes)] for i in range(len(edges)): solver.Add(nodes[edges[i][0] - 1] != nodes[edges[i][1] - 1]) monitors = [] collector = solver.FirstSolutionCollector() # This is a monitor collector.Add(nodes) monitors.append(collector) # impact-based parameters = pywrapcp.DefaultPhaseParameters() parameters.var_selection_schema = parameters.CHOOSE_MAX_AVERAGE_IMPACT parameters.value_selection_schema = parameters.SELECT_MIN_IMPACT db = solver.DefaultPhase(nodes, parameters) # lexicografic # db = solver.Phase(nodes, solver.INT_VAR_DEFAULT, solver.INT_VALUE_DEFAULT) # min domain # db = solver.Phase(nodes, solver.CHOOSE_MIN_SIZE, solver.INT_VALUE_DEFAULT) # random # db = solver.Phase(nodes, solver.CHOOSE_RANDOM, solver.INT_VALUE_DEFAULT) max_time = 1000 * 60 * 10 # 10 Minutes timelimit = solver.TimeLimit(max_time) # This is another monitor monitors.append(timelimit) if solver.Solve(db, monitors): print('Solved in {} ms. {} branches and {} failures'.format( collector.WallTime(0), collector.Branches(0), collector.Failures(0))) else: print('Not solved')
def main(problem, rows, cols, max_steps): # Create the solver. solver = pywrapcp.Solver("Rogo grid puzzle") # # data # W = 0 B = -1 print("rows: %i cols: %i max_steps: %i" % (rows, cols, max_steps)) problem_flatten = [problem[i][j] for i in range(rows) for j in range(cols)] max_point = max(problem_flatten) print("max_point:", max_point) max_sum = sum(problem_flatten) print("max_sum:", max_sum) print() # # declare variables # # the coordinates x = [solver.IntVar(0, rows - 1, "x[%i]" % i) for i in range(max_steps)] y = [solver.IntVar(0, cols - 1, "y[%i]" % i) for i in range(max_steps)] # the collected points points = [ solver.IntVar(0, max_point, "points[%i]" % i) for i in range(max_steps) ] # objective: sum of points in the path sum_points = solver.IntVar(0, max_sum) # # constraints # # all coordinates must be unique for s in range(max_steps): for t in range(s + 1, max_steps): b1 = x[s] != x[t] b2 = y[s] != y[t] solver.Add(b1 + b2 >= 1) # calculate the points (to maximize) for s in range(max_steps): solver.Add(points[s] == solver.Element(problem_flatten, x[s] * cols + y[s])) solver.Add(sum_points == sum(points)) # ensure that there are not black cells in # the path for s in range(max_steps): solver.Add(solver.Element(problem_flatten, x[s] * cols + y[s]) != B) # get the path for s in range(max_steps - 1): solver.Add(abs(x[s] - x[s + 1]) + abs(y[s] - y[s + 1]) == 1) # close the path around the corner solver.Add(abs(x[max_steps - 1] - x[0]) + abs(y[max_steps - 1] - y[0]) == 1) # symmetry breaking: the cell with lowest coordinates # should be in the first step. for i in range(1, max_steps): solver.Add(x[0] * cols + y[0] < x[i] * cols + y[i]) # symmetry breaking: second step is larger than # first step # solver.Add(x[0]*cols+y[0] < x[1]*cols+y[1]) # # objective # objective = solver.Maximize(sum_points, 1) # # solution and search # # db = solver.Phase(x + y, # solver.CHOOSE_MIN_SIZE_LOWEST_MIN, # solver.ASSIGN_MIN_VALUE) # Default search parameters = pywrapcp.DefaultPhaseParameters() parameters.heuristic_period = 200000 # parameters.var_selection_schema = parameters.CHOOSE_MAX_SUM_IMPACT parameters.var_selection_schema = parameters.CHOOSE_MAX_AVERAGE_IMPACT # <- # parameters.var_selection_schema = parameters.CHOOSE_MAX_VALUE_IMPACT parameters.value_selection_schema = parameters.SELECT_MIN_IMPACT # <- # parameters.value_selection_schema = parameters.SELECT_MAX_IMPACT # parameters.initialization_splits = 10 db = solver.DefaultPhase(x + y, parameters) solver.NewSearch(db, [objective]) num_solutions = 0 while solver.NextSolution(): num_solutions += 1 print("sum_points:", sum_points.Value()) print("adding 1 to coords...") for s in range(max_steps): print("%i %i" % (x[s].Value() + 1, y[s].Value() + 1)) print() print("\nnum_solutions:", num_solutions) print("failures:", solver.Failures()) print("branches:", solver.Branches()) print("WallTime:", solver.WallTime())
def main(rows, row_rule_len, row_rules, cols, col_rule_len, col_rules): # Create the solver. solver = pywrapcp.Solver('Nonogram') # # variables # board = {} for i in range(rows): for j in range(cols): board[i, j] = solver.IntVar(0, 1, 'board[%i, %i]' % (i, j)) board_flat = [board[i, j] for i in range(rows) for j in range(cols)] # Flattened board for labeling. # This labeling was inspired by a suggestion from # Pascal Van Hentenryck about my (hakank's) Comet # nonogram model. board_label = [] if rows * row_rule_len < cols * col_rule_len: for i in range(rows): for j in range(cols): board_label.append(board[i, j]) else: for j in range(cols): for i in range(rows): board_label.append(board[i, j]) # # constraints # for i in range(rows): check_rule(row_rules[i], [board[i, j] for j in range(cols)]) for j in range(cols): check_rule(col_rules[j], [board[i, j] for i in range(rows)]) # # solution and search # parameters = pywrapcp.DefaultPhaseParameters() parameters.heuristic_period = 200000 db = solver.DefaultPhase(board_label, parameters) print('before solver, wall time = ', solver.WallTime(), 'ms') solver.NewSearch(db) num_solutions = 0 while solver.NextSolution(): print() num_solutions += 1 for i in range(rows): row = [board[i, j].Value() for j in range(cols)] row_pres = [] for j in row: if j == 1: row_pres.append('#') else: row_pres.append(' ') print(' ', ''.join(row_pres)) print() print(' ', '-' * cols) if num_solutions >= 2: print('2 solutions is enough...') break solver.EndSearch() print() print('num_solutions:', num_solutions) print('failures:', solver.Failures()) print('branches:', solver.Branches()) print('WallTime:', solver.WallTime(), 'ms')
def magic_square(n, var_selection_schema, value_selection_schema, luby_restart_frequency=None): max_number = n * n solver = pywrapcp.Solver('magic_square') board = [] flat_board = [] for i in range(n): board.append([]) for j in range(n): var = solver.IntVar(1, max_number, 'x_{}{}'.format(i, j)) board[i].append(var) flat_board.append(var) sum = solver.IntVar(1, max_number * (1 + max_number) // 2) solver.Add(solver.AllDifferent(flat_board)) for i in range(n): solver.Add(solver.Sum([board[i][j] for j in range(n)]) == sum) solver.Add(solver.Sum([board[j][i] for j in range(n)]) == sum) solver.Add(solver.Sum([board[i][i] for i in range(n)]) == sum) solver.Add(solver.Sum([board[i][n - i - 1] for i in range(n)]) == sum) monitors = [] parameters = pywrapcp.DefaultPhaseParameters() parameters.var_selection_schema = getattr(parameters, var_selection_schema) parameters.value_selection_schema = getattr(parameters, value_selection_schema) db = solver.DefaultPhase(flat_board, parameters) collector = solver.FirstSolutionCollector() collector.Add(flat_board) collector.Add(sum) monitors.append(collector) max_time = 1000 * 60 * 10 timelimit = solver.TimeLimit(max_time) monitors.append(timelimit) if luby_restart_frequency: monitors.append(solver.LubyRestart(luby_restart_freq)) if solver.Solve(db, monitors): print('Solved in {} ms. {} branches and {} failures'.format( collector.WallTime(0), collector.Branches(0), collector.Failures(0))) count = 0 while solver.NextSolution(): count += 1 board = '' for r in range(n * n): board += "|" + str(flat_board[r].Value()) + "|" # if r == k*n with k from 1 to n if (r + 1) % n == 0: board += "\n" print(board) print() #utils.print_magic_square(flat_board, n, collector) else: print('Time out')