如何使用 CP-SAT 求解器找到一个 3D 数组，该数组对行、列和管（代表学校班级、学期和上课日）有约束？

Question

I will be grateful to anyone who can help me to write some Python code to create a 21×2×3 array, indexed with i, j and k, and fill it with eighty-four "0" values and the values "Ava", "Bob", "Joe", "Mia", "Sam", "Tom", "Zoe" in such a way that:

1. fixed the index i you have exactly two empty 2-tuples and one 2-tuple with different non-zero values;

2. fixed the index k you have exactly fourteen empty 2-tuples and seven 2-tuple with different non-zero values;

3. fixed the indexes j and k you have a 21-tuple with fourteen zero values and exactly one occurrence of each of the non-zero values, respecting the following constraints:

   a) "Ava" can appear only in a row with index 0, 1, 4, 6, 10, 11, 13, 14, 15, 19 or 20;

   b) "Bob" can appear only in a row with index 2, 3, 5, 7, 8, 9, 12, 16, 17 or 18;

   c) "Joe" can appear only in a row with index 2, 4, 5, 7, 8, 10, 14, 15, 18 or 20;

   d) "Mia" can appear only in a row with index 0, 1, 3, 6, 9, 12, 13, 16, 17 or 19;

   e) "Sam" can appear only in a row with index 1, 2, 7, 9, 15, 17 or 20;

   f) "Tom" can appear only in a row with index 0, 3, 8, 10, 12, 16 or 19;

   g) "Zoe" can appear only in a row with index 4, 5, 6, 11, 13, 14 or 18.

As a result I would like to obtain something like this:

[ 0   0       [Tom Mia      [ 0   0
  0   0        Ava Sam        0   0
  0   0        Sam Bob        0   0
  0   0        Bob Tom        0   0
  0   0         0   0        Joe Zoe
  0   0        Joe Zoe        0   0
  0   0         0   0        Zoe Ava
 Joe Sam        0   0         0   0
  0   0         0   0        Tom Bob
  0   0         0   0        Mia Sam
 Tom Ava        0   0         0   0
 Ava Zoe        0   0         0   0
 Bob Mia        0   0         0   0
  0   0        Mia Ava        0   0
  0   0        Zoe Joe        0   0
 Sam Joe        0   0         0   0
  0   0         0   0        Bob Tom
  0   0         0   0        Sam Mia
 Zoe Bob        0   0         0   0
 Mia Tom        0   0         0   0
  0   0 ]       0   0 ]      Ava Joe]

Rows represent school classes, columns represent school terms (there are 2 of them), tubes represent class days (there are 3 of them: Monday, Wednesday ans Friday). So the first horizontal slice of the above solution means that class 1A has lesson only on Wednesday, in the the first term with teacher Tom and in the second term with teacher Mia. (Teachers can only work in some classes and not in others.)

Thanks in advance!

PS
As a starting point, I tried to attack the following toy problem:
Enumerate all arrays with a given number of rows and 3 columns which are two-thirds filled with "0" and one-third filled with "1" in such a way that summing the values in each row you always get 1 and summing the values in each column you always get rows / 3 .
Finally, after struggling a bit, I think I managed to get a solution with the following code, that I kindly ask you to correct or improve. (I have set rows = 6 because the number of permutations of the obvious solution is 6,/(2!*2!*2!) = 90, whereas setting rows = 21 I would have got 21,/(7,*7.*7!) = 399,072,960 solutions.)

from ortools.sat.python import cp_model

# create model
model = cp_model.CpModel()

# create variables
rows = 6
columns = 3
x = []
for i in range(rows):
  x.append([model.NewBoolVar("x[{}][{}]".format(i, j)) for j in range(columns)])

# add constraints
for i in range(rows):
  model.Add(sum(x[i]) == 1)

for j in range(columns):
  model.Add(sum(x[i][j] for i in range(rows)) == rows//columns)


class VarArraySolutionPrinter(cp_model.CpSolverSolutionCallback):

    def __init__(self, variables, limit):
        cp_model.CpSolverSolutionCallback.__init__(self)
        self.__variables = variables
        self.__solution_count = 0
        self.__solution_limit = limit

    def solution_count(self):
        return self.__solution_count

    def on_solution_callback(self):
        self.__solution_count += 1
        for v in self.__variables:
          print('%i' % (self.Value(v)), end='')
          #  print('%s=%i' % (v, self.Value(v)), end=' ')
        print()
        if self.__solution_count >= self.__solution_limit:
          print('Stop search after %i solutions' % self.__solution_limit)
          self.StopSearch()


# create solver and solve model
solver = cp_model.CpSolver()
solution_limit = 100000
solution_printer = VarArraySolutionPrinter([*x[0], *x[1], *x[2], *x[3], *x[4], *x[rows-1]], solution_limit)
solver.parameters.enumerate_all_solutions = True
# solver.parameters.log_search_progress = True
# Works better with more workers (at least 8, 16 if enough cores).
# solver.parameters.num_workers = 8
status = solver.Solve(model, solution_printer)

print('Number of solutions found: %i' % solution_printer.solution_count())

Answer 1

Your "toy" problem is definitely going in the right direction.

For your actual problem, try making a 21×2×3x8 array x indexed with i, j, k and p (for person) of BoolVar's. The last index represents the person, it will need 0 to represent "nobody" and for the rest Ava = 1, Bob = 2, etc., so its max value will be one more than the number of people. If the variable X[i,j,k,p] is true (1) it means that the given person p is present at the index i, j, k. If X[i,j,k,0] is true, it means a 0 = nobody is present at i, j, k.

For all i, j, k, constrain the sum of x[i, j, k, p] for p in the range of people to be equal to 1, so exactly nobody or one person is selected at a given slot.

For point 1: fixed the index i you have exactly two empty 2-tuples and one 2-tuple with different non-zero values:

For all i constrain the sum of x[i, j, k, p] for all j, k, p in their respective ranges (except p = 0) to be exactly equal to 2, so exactly two people are in a given row.

For all i, k, and for p = 0, add the implications

x[i, 0, k, 0] == x[i, 1, k, 0]

This will ensure that if one of the pair is 0, so is the other.

For all i, k and p except p = 0, add the implications

x[i, 0, k, p] implies x[i, 1, k, p].Not and

x[i, 1, k, p] implies x[i, 0, k, p].Not

This will ensure a tuple will consist of two different people.

Alternative formulation of the last part:

For all i and p except p = 0, constraint the sum of x[i, j, k, p] for all j and k to be exactly equal to 1.

For point 2: fixed the index k you have exactly fourteen empty 2-tuples and seven 2-tuple with different non-zero values;

For all k constrain the sum of x[i, j, k, p] for all i, j, p in their respective ranges to be exactly equal to 7, so exactly seven people are in a given column.

For all k and p except p = 0, constraint the sum of x[i, j, k, p] for all i and j to be exactly equal to 1, so each person appears exactly once in the column.

For point 3:

For all j and k, Constrain x[i, j, k, p] == 0 for the row i in which each person p can't appear.

Let us know how it works.

Answer 2

You're taking a pretty big swing if you are new to the trifecta of python , linear programming, and pulp , but the problem you describe is very doable...perhaps the below will get you started. It is a smaller example that should work just fine for the data you have, I just didn't type it all in.

A couple notes:

• The below is a linear program. It is "naturally integer" as coded, preventing the need to restrict the domain of the variables to integers, so it is much easier to solve. (A topic for you to research, perhaps).
• You could certainly code this up as a constraint problem as well, I'm just not as familiar. You could also code this up like a matrix as you are doing with i, j, k, but most frameworks allow more readable names for the sets.
• The teaching day M/W/F is arbitrary and not linked to anything else in the problem, so you can (externally to the problem), just pick 1/3 of the assignments per day from the solution for each course & term.
• The transition from the verbiage to the constraint formulation is most of the magic in linear programming and you'd be well suited with an introductory text if you continue along!

---

Code:

# teacher assignment

import pulp
from itertools import chain

# some data...
teach_days = {'M', 'W', 'F'}
terms = {'Spring', 'Fall'}
courses = {'Math 101', 'English 203', 'Physics 201'}
legal_asmts = { 'Bob': {'Math 101', 'Physics 201'},
                'Ann': {'Math 101', 'English 203'},
                'Tim': {'English 203'},
                'Joe': {'Physics 201'}}

# quick sanity check
assert courses == set.union(*chain(legal_asmts.values())), 'course mismatch'

# set up the problem

prob = pulp.LpProblem('teacher_assignment', pulp.LpMaximize)

# make a 3-tuple index of the term, class, teacher
idx = [(term, course, teacher) for term in terms for course in courses for teacher in legal_asmts.keys()]

assn = pulp.LpVariable.dicts('assign', idx, cat=pulp.LpContinuous, lowBound=0)

# OBJECTIVE:  teach as many courses as possible within constraints...
prob += pulp.lpSum(assn)

# CONSTRAINTS
# teach each class no more than once per term
for term in terms:
    for course in courses:
        prob += pulp.lpSum(assn[term, course, teacher] for teacher in legal_asmts.keys()) <= 1

# each teacher no more than 1 course per term
for term in terms:
    for teacher in legal_asmts.keys():
        prob += pulp.lpSum(assn[term, course, teacher] for course in courses) <= 1

# each teacher can only teach within legal assmts, and if legal, only teach it once
for teacher in legal_asmts.keys():
    for course in courses:
        if course in legal_asmts.get(teacher):
            prob += pulp.lpSum(assn[term, course, teacher] for term in terms) <= 1
        else:  # it is not legal assignment
            prob += pulp.lpSum(assn[term, course, teacher] for term in terms) <= 0


prob.solve()

#print(prob)

# Inspect results...
for i in idx:
    if assn[i].varValue:  # will be true if value is non-zero
        print(i, assn[i].varValue)

Output:

Coin0008I MODEL read with 0 errors
Option for timeMode changed from cpu to elapsed
Presolve 16 (-10) rows, 12 (-12) columns and 32 (-40) elements
Perturbing problem by 0.001% of 1 - largest nonzero change 0.00010234913 ( 0.010234913%) - largest zero change 0
0  Obj -0 Dual inf 11.99913 (12)
10  Obj 5.9995988
Optimal - objective value 6
After Postsolve, objective 6, infeasibilities - dual 0 (0), primal 0 (0)
Optimal objective 6 - 10 iterations time 0.002, Presolve 0.00
Option for printingOptions changed from normal to all
Total time (CPU seconds):       0.00   (Wallclock seconds):       0.00

('Spring', 'Math 101', 'Bob') 1.0
('Spring', 'Physics 201', 'Joe') 1.0
('Spring', 'English 203', 'Ann') 1.0
('Fall', 'Math 101', 'Ann') 1.0
('Fall', 'Physics 201', 'Bob') 1.0
('Fall', 'English 203', 'Tim') 1.0