def main():
"""Solves the gate scheduling problem."""
model = cp_model.CpModel()
jobs = [[3, 3], [2, 5], [1, 3], [3, 7], [7, 3], [2, 2], [2, 2], [5, 5],
[10, 2], [4, 3], [2, 6], [1, 2], [6, 8], [4, 5], [3, 7]]
max_length = 10
horizon = sum(t[0] for t in jobs)
num_jobs = len(jobs)
all_jobs = range(num_jobs)
intervals = []
intervals0 = []
intervals1 = []
performed = []
starts = []
ends = []
demands = []
for i in all_jobs:
# Create main interval.
start = model.NewIntVar(0, horizon, 'start_%i' % i)
duration = jobs[i][0]
end = model.NewIntVar(0, horizon, 'end_%i' % i)
interval = model.NewIntervalVar(start, duration, end,
'interval_%i' % i)
starts.append(start)
intervals.append(interval)
ends.append(end)
demands.append(jobs[i][1])
performed_on_m0 = model.NewBoolVar('perform_%i_on_m0' % i)
performed.append(performed_on_m0)
# Create an optional copy of interval to be executed on machine 0.
start0 = model.NewIntVar(0, horizon, 'start_%i_on_m0' % i)
end0 = model.NewIntVar(0, horizon, 'end_%i_on_m0' % i)
interval0 = model.NewOptionalIntervalVar(start0, duration, end0,
performed_on_m0,
'interval_%i_on_m0' % i)
intervals0.append(interval0)
# Create an optional copy of interval to be executed on machine 1.
start1 = model.NewIntVar(0, horizon, 'start_%i_on_m1' % i)
end1 = model.NewIntVar(0, horizon, 'end_%i_on_m1' % i)
interval1 = model.NewOptionalIntervalVar(start1, duration, end1,
performed_on_m0.Not(),
'interval_%i_on_m1' % i)
intervals1.append(interval1)
# We only propagate the constraint if the tasks is performed on the machine.
model.Add(start0 == start).OnlyEnforceIf(performed_on_m0)
model.Add(start1 == start).OnlyEnforceIf(performed_on_m0.Not())
# Max Length constraint (modeled as a cumulative)
model.AddCumulative(intervals, demands, max_length)
# Choose which machine to perform the jobs on.
model.AddNoOverlap(intervals0)
model.AddNoOverlap(intervals1)
# Objective variable.
makespan = model.NewIntVar(0, horizon, 'makespan')
model.AddMaxEquality(makespan, ends)
model.Minimize(makespan)
# Symmetry breaking.
model.Add(performed[0] == 0)
# Solve model.
solver = cp_model.CpSolver()
solver.Solve(model)
# Output solution.
if visualization.RunFromIPython():
output = visualization.SvgWrapper(solver.ObjectiveValue(), max_length,
40.0)
output.AddTitle('Makespan = %i' % solver.ObjectiveValue())
color_manager = visualization.ColorManager()
color_manager.SeedRandomColor(0)
for i in all_jobs:
performed_machine = 1 - solver.Value(performed[i])
start = solver.Value(starts[i])
d_x = jobs[i][0]
d_y = jobs[i][1]
s_y = performed_machine * (max_length - d_y)
output.AddRectangle(start, s_y, d_x, d_y,
color_manager.RandomColor(), 'black',
'j%i' % i)
output.AddXScale()
output.AddYScale()
output.Display()
else:
print('Solution')
print(' - makespan = %i' % solver.ObjectiveValue())
for i in all_jobs:
performed_machine = 1 - solver.Value(performed[i])
start = solver.Value(starts[i])
print(' - Job %i starts at %i on machine %i' %
(i, start, performed_machine))
print('Statistics')
print(' - conflicts : %i' % solver.NumConflicts())
print(' - branches : %i' % solver.NumBranches())
print(' - wall time : %f ms' % solver.WallTime())
def solve_hidato(puzzle, index):
"""Solve the given hidato table."""
# Create the model.
model = cp_model.CpModel()
r = len(puzzle)
c = len(puzzle[0])
if not visualization.RunFromIPython():
print('')
print('----- Solving problem %i -----' % index)
print('')
print(('Initial game (%i x %i)' % (r, c)))
print_matrix(puzzle)
#
# declare variables
#
positions = [
model.NewIntVar(0, r * c - 1, 'p[%i]' % i) for i in range(r * c)
]
#
# constraints
#
model.AddAllDifferent(positions)
#
# Fill in the clues
#
for i in range(r):
for j in range(c):
if puzzle[i][j] > 0:
model.Add(positions[puzzle[i][j] - 1] == i * c + j)
# Consecutive numbers much touch each other in the grid.
# We use an allowed assignment constraint to model it.
close_tuples = build_pairs(r, c)
for k in range(0, r * c - 1):
model.AddAllowedAssignments([positions[k], positions[k + 1]],
close_tuples)
#
# solution and search
#
solver = cp_model.CpSolver()
status = solver.Solve(model)
if status == cp_model.OPTIMAL:
if visualization.RunFromIPython():
output = visualization.SvgWrapper(10, r, 40.0)
for i, var in enumerate(positions):
val = solver.Value(var)
x = val % c
y = val // c
color = 'white' if puzzle[y][x] == 0 else 'lightgreen'
output.AddRectangle(x, r - y - 1, 1, 1, color, 'black',
str(i + 1))
output.AddTitle('Puzzle %i solved in %f s' %
(index, solver.WallTime()))
output.Display()
else:
print_solution(
[solver.Value(x) for x in positions],
r,
c,
)
print('Statistics')
print(' - conflicts : %i' % solver.NumConflicts())
print(' - branches : %i' % solver.NumBranches())
print(' - wall time : %f s' % solver.WallTime())
# Objective variable.
makespan = model.NewIntVar(0, horizon, 'makespan')
model.AddMaxEquality(makespan, ends)
model.Minimize(makespan)
# Symmetry breaking.
model.Add(performed[0] == 0)
# Solve model.
solver = cp_model.CpSolver()
solver.Solve(model)
# Output solution.
if visualization.RunFromIPython():
output = visualization.SvgWrapper(solver.ObjectiveValue(), max_length,
40.0)
output.AddTitle('Makespan = %i' % solver.ObjectiveValue())
color_manager = visualization.ColorManager()
color_manager.SeedRandomColor(0)
for i in all_jobs:
performed_machine = 1 - solver.Value(performed[i])
start = solver.Value(starts[i])
dx = jobs[i][0]
dy = jobs[i][1]
sy = performed_machine * (max_length - dy)
output.AddRectangle(start, sy, dx, dy, color_manager.RandomColor(),
'black', 'j%i' % i)
output.AddXScale()
output.AddYScale()