1. An Investigation of the Course-Section Assignment Problem
Assoc. Prof. Zeki Bayram
Eastern Mediterranean University
T.R.N.Cyprus

2. Problem Specification
Student registration period
Students should be registered to courses with the minimal number of conflicts
For a specific student, courses to be taken are known. Meeting times of course-sections also known.
Need to decide on which sections to register with the minimum number of clashes

3. Problem Specification
Student/advisor preferences also play a role
Course-section assignment problem: given the courses the student should take, generate schedules for the student, in increasing order of the number of conflicts each schedule contains, up to a specified maximum
Student and his advisor can then choose one they prefer (semi-automated)

4. Computational Complexity
Scheduling problems which are decision problems, of a similar nature, are NP-complete
Our problem is a function problem, rather than a decision problem – enumeration, given as input courses, and section information about courses
Conjecture: Related decision problem “Is it possible to schedule n courses with at most k conflicts” is NP-complete.

5. Proposed Algorithm – high level
Repeat
Generate all schedules with exactly i conflicts
i  i + 1
Until the desired number of schedules have been generated

6. Algorithm Issues
Finding schedules at a given level done through backtracking search
Search space pruned if the total number of conflicts already exceed the currently allowed level
Implemented as a Javascript program and runs in the Web browser’s JavaScript engine

7. Web application – data entry page

8. Web application – Results page

9. Formal Problem Specification
Definition 1. A meeting-time is a day-period pair, such as <Monday, 3 >, meaning the third period (i.e. 10:30) on Monday.
Definition 2. The function rep(D,P) is defined as (val(D) ∗ 8)+P, where <D, P > is a meeting-time, val(Monday) = 0, val(Tuesday) = 1, val(Wednesday) =2, val(Thursday) = 3 and val(Friday) = 4. rep(D, P) is a unique integer representation of a meeting-time < D,P >.

10. Formal Problem Specification
Definition 3. A course-section assignment is a function that maps a course to one of its sections.
Definition 4. The function meetingTimes(C,S) returns the set of meeting times (represented as integers) of section S of course C. In other words, x ∈ meetingT imes(C, S) iff < D,P > is a meeting-time of section S of course C and x = rep(D, P).

11. Formal Problem Specification
Definition 5. The function nconf(assign) takes a course-section assignment as an argument and returns the number of conflicts it contains. Specifically, let < C1, . . ., Cn > be a list of courses and assign be a course-section assignment. nconf(assign) is defined as | meetingT imes(assign(C1)) | |meetingTimes(assign(Cn)) | − |meetingT imes(assign(C1)) ∪ ∪ meetingTimes(assign(Cn))|

12. Formal Problem Specification
Definition 6. Given a list of courses < C1, , Cn >, the course-section assignment problem (CSAP) is to generate a sequence < ass1, ass2, > of course-section assignments in such a way that every assignment appears exactly once in the sequence, and if assi comes before assj in the sequence, then nconf(assi) ≤ nconf(assj).

13. Algorithm in Pseudo-Code

14. Input to the Algorithm
C, the maximum number of conflicts that can be tolerated.
List of courses course1, course2, , courseL for which we need to find schedules with at most C conflicts.
K, the number of sections per course.
The function meetingTimes(i, j) that gives the bitmap for course i, section j.
maxSolutions, the maximum number of solutions that should be generated

15. Output of the Algorithm
All combinations of course sections such that the number of conflicts does not exceed C and solutions are generated in increasing order of the number of conflicts they contain, up to a maximum of max solutions solutions

16. Algorithm (part 1) declare current as an array[0..L] of bitmaps
declare nc as an array[0..L] of integer
declare next as an array[1..L +1] of integer
declare result as an array[1..L] of integer
ns ← 0 // number of solutions generated so far
for c ← 0 to C
i ← 1 // the next course to process
next[1] ← 1 // section 1 of course 1 to be processed first
current[0] ← ( ) // bitmap of forty zeroes
nc[0] ← 0 // initial node contains no conflicts

17. Algorithm (part 2)
loop
if ns > max solutions then exit program end if
if i = 0 then exit loop end if
if next[i]> K then i ← i − 1 continue loop end if
if i = L + 1 then
if c = nc[i − 1] then
print the result array
ns ← ns + 1
end if
i ← i −1 // backtrack
continue loop

18. Algorithm (part 3) if (newConflicts + nc[i − 1]) ≤ c then
newConflicts ← countOnes(meetingTimes(i, next[ i ])  current[i − 1])
if (newConflicts + nc[i − 1]) ≤ c then
nc[i] ← nc[i − 1] + newConflicts
current[i] ← current[ i − 1 ] meetingTimes(i, next[ i ])
result[ i ] ← next[ i ]
next[ i ] ← next[ i ] + 1
next[ i +1 ] ← 1
i ← i + 1
continue loop
end if
next[ i ] ← next[ i ] end loop
end for

19. Implicit Tree traversed by the algorithm

20. Algorithm Complexity – Worst Case
Number of nodes visited by the algorithm an accurate measure of its time complexity
In the implicit tree traversed by the algorithm:
Level of the root = 0
Level of the leaf nodes = N
Branching factor (number of sections of a course) = K
Number of nodes in the tree =

21. Algorithm Complexity – Worst case
C = Maximum number of conflicts that are tolerated
Algorithm makes C+1 passes over the implicit tree
Number of nodes visited in tree tree by the algorithm =

22. Algorithm Complexity – Average Case
Notation: = probability that a node at level b with exactly Y conflicts is visited
c’ = Maximum number of conflicts we can tolerate in a specific iteration of the algorithm
Given c’, the expected number of nodes visited by the algorithm if we can tolerate c’ or less number of conflicts =

23. Algorithm Complexity – Average case
C = Maximum number of conflcits we can tolerate in the solution
Average case comlexity for the whole algorithm =

24. Computing P(j@Li) Base cases
= 1
= 1
= 0 for j > 0
= 0 for j > 0

25. Computing P(j@Li) Base cases (cont)
R = Number of hours a course is taught in a week =

26. Computing P(j@Li) Recursive case
Let
mean that k new conflicts are introduced when going from a node at level i-1 to a node at level i.
mean the probability of introducing k new conflicts when going from a node at level i-1 to a node at level i, if there are already e conflicts at the node at level i-1.

27. Computing P(j@Li) Recursive case
For i>2, we have
where

28. Explanation R is the number of hours per week each course is taught.
At level i-1, we have alrady allocated sections to i-1 courses. Since they have e conflicts, (i-1)R-e slots (out of 40) are already taken.To go to the next level node, k slots of the new course must coincide with already taken slots at level i-1, and R-k slots must coincide with the free slots at level i-1.

29. Explanation
is just all possible ways of choosing R slots from 40 slots.

30. Conclusion We defined formally the course-section assignment problem
We proposed an algorithm for it
We investigated the time-complexity of the algorithm using a probabilistic approach
We showed a Web application that implements the algorithm

31. Future Work
Investigating the applicability of the proposed algorithm to similar scheduling problems
Adapting the probabilistic approach for computing the the average-case complexity of the algorithm to other scheduling algorithms

32. References