SAT解决人员、技能、景点位置和日程安排问题

Question

While I am not new to development, I am very new to SAT solving. I have an old codebase solving a schema problem (not using SAT) and I am trying to use google OR tools and a combination of “Employee Scheduling” and “The Job Shop Problem”. Base problem: Each employee has his own schedule for the day. Each day has X attacktions that must be manned For an employee to be allowed to be assigned to an attraction he/she must have the appropiate training. Now I have the code for the first two (using C#) but i am struggeling to wrap my head around how to add the last bit to the pussle. This is my code this far:

Now do I need to extend this with yet one more dimension something like:

private CpModel AddExactlyOnePersonToOnePosAndOneTimeslot(int[] personel, int[] timeslots, int[] positions, Dictionary<(int, int), bool> skills, CpModel model, Dictionary<(int, int, int), BoolVar> personelTimePos)
{
List<ILiteral> literals = new List<ILiteral>();
        // Add exaktly one employee on each timeslotposition

        // Each position is assigned to exactly one personel in the time period.
        foreach (var n in personel)
        {
            foreach (var d in timeslots)
            {
                foreach (var s in positions)
                {
                    literals.Add(personelTimePos[(n, d, s)]);
                }
                model.AddExactlyOne(literals);
                literals.Clear();
            }
        }

        // One person works at most on one postion during any given timeslot
        foreach (var s in positions)
        {
            foreach (var d in timeslots)
            {
                foreach (var n in personel)
                {
                    literals.Add(personelTimePos[(n, d, s)]);
                }
                model.AddAtMostOne(literals);
                literals.Clear();
            }
        }

        return model;
    }

Now do I need to extend this with yet one more dimension something like:

foreach (var s in positions)
{
   foreach (var d in timeslots)
   {
      foreach (var n in personel)
      {
         foreach(var pp in personSkill)
         {
           
         }
       }
     }
} 

Or do I use a new variable something like:

foreach (var s in positions)
{
  foreach (var d in timeslots)
  {
    foreach (var n in personel)
    {
      var b = model.NewIntVar(0, 1, $"HasSkill_n{n}d{d}s{s}");
    }
   }
}

As I said, I am new to SAT solving, but I feel that this must be achievable. I just don't know how, I am not trying to have it "solved for me" I am trying to learn by doing.

Thank you in advance Regards Claes

*** COMPLETE CODE BELOW ***

using Google.OrTools.Sat;


namespace Scheduler1
{
    public class SmallTest3
    {

        public class SolutionPrinter : CpSolverSolutionCallback
        {
            public SolutionPrinter(int[] allPersonel, int[] allTimeSlots, int[] allPos,
                                   Dictionary<(int, int, int), BoolVar> allPersonelTimePos, int limit)
            {
                solutionCount_ = 0;
                personel = allPersonel;
                positions = allPos;
                timeslots = allTimeSlots;
                personelTimePos = allPersonelTimePos;
                solutionLimit_ = limit;
            }

            public override void OnSolutionCallback()
            {
                Console.WriteLine($"Solution #{solutionCount_}:");

                foreach (var pers in personel)
                    foreach (var time in timeslots)
                        foreach (var pos in positions)
                        {

                            if (Value(personelTimePos[(pers, time, pos)]) != 0)
                                Console.WriteLine($"Success personel: {pers}, Time {time}, Pos{pos} filling the position");
                        }
                solutionCount_++;
                if (solutionCount_ >= solutionLimit_)
                {
                    Console.WriteLine($"Stop search after {solutionLimit_} solutions");
                    StopSearch();
                }
            }

            public int SolutionCount()
            {
                return solutionCount_;
            }

            private int solutionCount_;


            int[] personel;
            int[] positions;
            int[] timeslots;
            Dictionary<(int, int, int), BoolVar> personelTimePos;
            private int solutionLimit_;

        }

        private int[] getPersonel(int noPersonel)
        {
            int personelId = 1000;
            var p = Enumerable.Range(0, noPersonel).ToArray();
            for (int i = 0; i < p.Length; i++)
            {
                p[i] = personelId + i;

            }
            return p;
        }
        private int[] getPos(int noPos)
        {

            var p = Enumerable.Range(0, noPos).ToArray();
            for (int i = 0; i < p.Length; i++)
            {
                p[i] = i;

            }
            return p;
        }
        private int[] getTimeSlots(int noTimeSlots)
        {

            var t = Enumerable.Range(0, noTimeSlots).ToArray();
            for (int i = 0; i < t.Length; i++)
            {
                t[i] = i;

            }
            return t;
        }

        private Dictionary<(int, int), bool> getSkillForPos(int[] personel, int[] position)
        {
            Dictionary<(int, int), bool> skill = new Dictionary<(int, int), bool>();
            var pi = 0;
            var posi = 0;
            foreach (var p in personel)
            {
                foreach (var pos in position)
                {
                    skill.Add((p, pos), false);

                    posi++;
                }
                pi++;
            }
            return skill;
        }

        public void run()
        {
            const int personelCnt = 1;
            const int positionsCnt = 1;
            const int timeslotsCnt = 1;

            int[] personel = getPersonel(personelCnt);
            int[] positions = getPos(positionsCnt);
            int[] timeslots = getTimeSlots(timeslotsCnt);
            Dictionary<(int, int), bool> skills = getSkillForPos(personel, positions);

            CpModel model = new CpModel();
            model.Model.Variables.Capacity = personelCnt * positionsCnt * timeslotsCnt;
            var personelTimePos = populateSchedule(personel, timeslots, positions, skills, model);
            model = AddExactlyOnePersonToOnePosAndOneTimeslot(personel, timeslots, positions, skills, model, personelTimePos);

            CpSolver solver = new CpSolver();
            solver.StringParameters += "linearization_level:0 " + "enumerate_all_solutions:true ";

            const int solutionLimit = 5;
            SolutionPrinter cb = new SolutionPrinter(personel, timeslots, positions, personelTimePos, solutionLimit);
            CpSolverStatus status = solver.Solve(model, cb);

            Console.WriteLine($"Solve status: {status}");

            Console.WriteLine("Statistics");
            Console.WriteLine($"  conflicts: {solver.NumConflicts()}");
            Console.WriteLine($"  branches : {solver.NumBranches()}");
            Console.WriteLine($"  wall time: {solver.WallTime()}s");


        }

        private Dictionary<(int, int, int), BoolVar> populateSchedule(int[] personel, int[] timeslots, int[] positions, Dictionary<(int, int), bool> skills, CpModel model)
        { // här skapar vi hela arrayen som ska täcka in alla möjliga kombinationer
          //Person    tid     pos
          //Janson    12:00   XOP
          //Janson    12:15   XOP
          //Janson    12:00   FF
          //Svenson   12:00   XOP
          //
          //

            Dictionary<(int, int, int), BoolVar> personelTimePos = new Dictionary<(int, int, int), BoolVar>(personel.Count() * positions.Count() * timeslots.Count());
            foreach (var n in personel)
                foreach (var d in timeslots)
                    foreach (var s in positions)
                    {

                        personelTimePos.Add((n, d, s), model.NewBoolVar($"TimeSlotPositionPersonel_n{n}d{d}s{s}"));


                    }
            return personelTimePos;
        }

        private CpModel AddExactlyOnePersonToOnePosAndOneTimeslot(int[] personel, int[] timeslots, int[] positions, Dictionary<(int, int), bool> skills, CpModel model, Dictionary<(int, int, int), BoolVar> personelTimePos)
        {
            List<ILiteral> literals = new List<ILiteral>();
            // Add exaktly one employee on each timeslotposition

            // Each position is assigned to exactly one personel in the time period.
            foreach (var n in personel)
            {
                foreach (var d in timeslots)
                {
                    foreach (var s in positions)
                    {
                        literals.Add(personelTimePos[(n, d, s)]);
                    }
                    model.AddExactlyOne(literals);
                    literals.Clear();
                }
            }

            // One person works at most on one postion during any given timeslot
            foreach (var s in positions)
            {
                foreach (var d in timeslots)
                {
                    foreach (var n in personel)
                    {
                        literals.Add(personelTimePos[(n, d, s)]);
                    }
                    model.AddAtMostOne(literals);
                    literals.Clear();
                }
            }




            return model;
        }

    }

}

Answer 1

Have you looked at the complex shift scheduling example?

It is located here . It is an adaptation of the original example in python located here .