Question

Everyone is familiar with the schedule problem in Computer Science.
I am not asking for an algorithm for this problem.

I just want to create my personal schedule for a semester at school

Here’s what you can assume:

Someone at my university already created classes, assigned teachers, rooms, etc. Thus, classes are already there, ready to be selected.

Only a relatively small portion of classes are availible to me. Say 25 classes.

I have to take 5 classes per semester (it could be more or less but let’s keep this simple)

All I want is some hints/clues as to how to create valid schedules and more importantly, optimal schedules.
Come to think of it, what would be an optimal schedule?
In my personal case, these classes are from 2 different faculties but I have been able to create a csv file that contains information like this:

M               
16:35:00    17:25:00    PHIL    375 Existentialism.
14:35:00    15:55:00    COMP    350 Numerical Computing.
14:35:00    15:55:00    COMP    208 Computers in Engineering.
14:35:00    15:25:00    PHIL    306 Philosophy of Mind.
14:35:00    15:25:00    PHIL    200 Introduction to Philosophy 
..etc

as you can see, everything is sorted by starting time (inverted) but there are conflicts. Same for all the other days of the week.
How can I create valid/optimal schedules? What things should I consider?

More information:

This is what I thought initially for things I should consider:

One priority for me would be to have classes as late as possible. So I would pick the 3 latest possible classes for Monday, wednesday and friday and 2 classes for Tuesday, Thursday. [see the comments for how I think I could implement this]

Another solution would be to get the least amount of ‘breaks’ in-between classes (or the opposite)

Another would be the earliest classes possible

Another priority would be getting all classes for 1 faculty in the same day and yet another one alternating 1 class for faculty A then 1 for faculty B,etc.
Missing something?

Answer 1

For this scale – I wouldn’t try too hard to avoid the simple to program brute-force solution.

There are 25!/(20!*5!)=53130 different possibilities to chose 5 courses from a list of 25. By simply checking all of them, and getting the best – an optimal solution is guaranteed. The run time for this scale is also not a problem for any modern machine.

A backtracking solution is simple enough – “guess” a course to add, invoke recursively until you have a list full, evaluate the solution. When you are back from the recursion – check a different possibility to chose a course.

Pseudo code:

best = 0
bestSol = nil
findCalendar(courses,candidate,i):
  if (take.size() == 5):
      t = evaluate(candidate)
      if (t > best):
          best = t
          bestSol = copy(candidate)
      return
  else if (i == courses.size()):
      //another stop clause, for non-feasible solutions (less then 5 were selected)
      return 
  for each j in range(i,courses.size()):
      candidate.add(courses[j]) //add this course to the candidate
      fidnCalendar(courses,candidate,j+1) //recurse to find the next courses for this candidate
      candidate.removeLast() //cklean up environment before next candidates

invoke with findCalendar(myCourses,[],0), when the algorithm is done – bestSol will hold the best calendar, and its value will be best