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')