A Comparison of Genetic Algorithms and Genetic Programming in Solving the
School Timetabling Problem
Rushil Raghavjee
Nelishia Pillay
School of Management, Information Technology and
Governance
University of KwaZulu-Natal
Pietermaritzburg, South Africa
[email protected]
School of Mathematics, Statistics and Computer
Science
University of KwaZulu-Natal
Pietermaritzburg, South Africa
[email protected]
studies evaluating GP for examination timetabling have used
GP to search a space of combinations of low-level
construction heuristics, which are used to construct a
timetable, while in this study GP explores a space of move
operators instead. The GP approach was found to produce
better results than the GA for a benchmark set of five
problems.
Section 2 discusses the school timetabling problem and
previous methods that have been applied to this domain. An
overview of genetic algorithms and genetic programming
and previous studies applying these approaches to solve the
school timetabling problem is provided in section 3.
Sections 4 and 5 describe the genetic algorithm and GP
approach used in this study to solve the school timetabling
problem respectively. Section 6 describes the experimental
setup used to evaluate the genetic algorithm and GP
approaches. The performance of both these approaches in
solving the school timetabling problem is discussed in
section 7. Finally, section 8 provides a summary of the
results of the study and future work.
Abstract— In this paper we compare the performance of
genetic algorithms and genetic programming in solving a set of
hard school timetabling problems. Genetic algorithms search a
solution space whereas genetic programming explores a
program space. While previous work has examined the use of
genetic algorithms in solving the school timetabling problem,
there has not been any research on the use of genetic
programming for this domain. The GA explores a space of
timetables to find an optimal timetable. GP on the other hand
searches for an optimal program which when executed will
produce a solution. Each program is comprised of operators
for timetable construction. The GA and GP were tested on the
Abramson set of school timetabling problems. Genetic
programming proved to be more effective than genetic
algorithms in solving this set of problems. Furthermore, the
results produced by both the GA and GP were found to be
comparative to methods applied to the same set of problems.
Keywords- genetic algorithms; genetic programming; school
timetabling problem
I.
INTRODUCTION
II.
Educational timetabling encompasses university course
timetabling, university examination timetabling and school
timetabling. These three problems are very different and a
solution found for one type cannot be used to solve either of
the other two problems. The paper focuses on school
timetabling which has not been as well researched as
university course and examination timetabling. The school
timetabling problem involves allocating resources, such as
teachers, classes and venues, to timetable slots such that
certain hard constraints have been met and soft constraint
violations have been minimized. The main contribution of
the study presented in this paper is to compare the
performance of genetic algorithms (GA) and genetic
programming in solving the school timetabling problem.
The GA explores a solution space of potential timetables. GP
on the other hand searches a program space. The optimal
program is implemented to find a solution to the problem.
For the domain of school timetabling, each program is
composed of operators for constructing a timetable. While
previous work has been conducted on the use of GP for
examination timetabling, GP has not previously been applied
to solve the school timetabling problem. Furthermore, the
c
978-1-4673-4769-3/12/$31.00 2012
IEEE
THE SCHOOL TIMETABLING PROBLEM (STP)
The school timetabling problem involves the allocation
of teachers, classes, venues and other resources to
timetabling periods in order to satisfy the hard constraints of
the problem and to minimize the soft constraints. A
combination of resources (for example a teacher that is
required to teach a class at a particular venue) is commonly
referred to as a tuple. These hard and soft constraints differ
depending on the needs and resources available to the school.
The most common hard constraint found in all school
timetabling problems is that the timetable must be clash-free.
A clash occurs in the event that a teacher is scheduled to
teach two or more classes at the same time, if a class is
scheduled to meet two or more teachers at the same time or if
a venue has been allocated to multiple classes or multiple
teachers at the same time. A feasible timetable is defined as
a timetable that satisfies all the hard constraints of a problem.
The school timetabling problem may also have soft
constraints associated with it. Soft constraints are
requirements that we would prefer the timetable to satisfy. If
a soft constraint has been violated, the timetable is still
considered feasible. The objective is to minimize the soft
constraint cost which estimates the quality of a timetable.
98
An example of a soft constraint would be teachers preferring
to teach either in the mornings or the afternoons. Each school
timetabling problem has a different set of hard constraints
and soft constraints that must be addressed.
Various methods have been applied to solve the school
timetabling problem. Schaerf [1] applied a tabu search to
solve the school timetabling problem for an Italian school. A
two dimensional matrix was used to represent the school
timetable. An initial candidate solution was created randomly
and the tabu search was applied in order to find a feasible
timetable. Moves, involving the swapping of tuples, were
used to get from one neighbourhood to the next. The
technique was applied to three Italian high schools with each
high school differing in the number of teachers, lessons and
constraints. The tabu search managed to find feasible
timetables for all three schools. Randall [4] has also used a
tabu search to solve the Abramson set of school timetabling
problems.
Abramson [2] employed simulated annealing to solve the
school timetabling problem for an Australian school. An
initial candidate solution is created by randomly allocating
tuples. Tuples move freely around the timetable and as the
cost of the timetable decreases, these tuples freeze into their
timeslots. If the cost of the timetable increases, then the
tuples are heated, resulting in them freely moving through
the timetable. Liu [3] and Randall [4] have also successfully
applied simulated annealing to the school timetabling
problem.
Beligiannis et al. [5] solve the Greek school timetabling
problem using particle swarm optimization. A population of
particles (candidate solutions) is initially created and these
particles are evolved or improved over a predefined number
of generations. As the number of generations increase,
particles that are not evolving at a fast enough rate are
deactivated and removed from the population. Timetables
were evolved by either swapping the tuples or by swapping
columns (all the tuples in a single timeslot). The algorithm
terminates when either an acceptable solution is found or the
generation limit has been reached. The method was applied
to several Greek school timetabling problems. Results
showed that particle swarm optimization produced better
timetables than other techniques including evolutionary
algorithms and constraint programming.
Smith et al. [6] have tested various Hopfield neural
networks to solve the Abramson set of school timetabling
problems. Neural networks were found to perform better
than simulated annealing, Tabu search and greedy search in
solving these problems.
Hybrid approaches have also been applied to solving the
school timetabling problem. Avella et al. [7] use a
combination of simulated annealing and very large
neighbourhood search to solve the Abramson set of
problems.
III.
GENETIC ALGORITHMS AND GENETIC PROGRAMMING
A genetic algorithm is a metaheuristic, largely influenced
by Darwin’s theory of evolution [8], which iteratively refines
an initial population of candidate solutions until some
termination criteria have been met. The genetic algorithm
begins by randomly creating an initial population of
individuals. Each individual is then evaluated using a fitness
function and a fitness value is assigned to each individual
indicating how close a candidate solution is to an ideal
solution. A selection method is used to select parents for
regeneration. Common techniques used to select parents
include tournament selection, roulette wheel selection and
rank selection. Genetic operators are applied to chosen
parents to produce one or more offspring. The most common
genetic operators used are mutation, crossover and
reproduction. The process of evaluation, selection and
application of genetic operators continues for every
generation until either an individual’s fitness value reaches a
predefined target value or until a set number of generations
has been reached.
Banzhaf [9] defines genetic programming as a direct
evolution of programs (or blocks of code) for the purpose of
inductive learning. Genetic programming differs from
genetic algorithms in that the individuals, rather than being
candidate solutions, are candidate programs which when
executed will create a solution to the problem. These
candidate programs are iteratively evolved until an optimal
program is found.
While there have been previous investigations into the
use of genetic programming for solving the examination
timetabling problem, GP has not been applied to the domain
of school timetabling. However, several studies have used
genetic algorithms or evolutionary algorithms to solve the
school timetabling problem. Bedoya and Santos [10] used a
genetic algorithm to solve two school timetabling problems.
Roulette wheel selection was used to choose parents and
mutation was applied to the chosen parents. Abramson and
Abela [11] developed a genetic algorithm to solve the
Australian school timetabling problem. Parents were
randomly chosen from the population. The genetic operators
applied to the parents were crossover and mutation. Hill
climbing was used to force newly created offspring to be at
least as fit as the parent. A repair algorithm was applied to
resulting offspring to deal with incorrectly placed or missing
tuples which may have resulted from application of the
genetic operators. Beligiannis et al. [12] solved the Greek
school timetabling problem using an evolutionary algorithm.
Timetables in the initial population were created by
randomly allocating tuples to timeslots. A linear rank
selection method was used to select parents. Mutation was
the only genetic operator used. The evolutionary algorithm
was applied to seven different data sets and feasible
timetables were found for all problems. The timetables
produced were also of a better quality than the actual
timetables used by the school. Di Steffano and Tettamanzi
[13] developed an evolutionary algorithm to solve the Italian
school timetabling problem. Initial timetables were created
by either randomly allocating tuples or by using a greedy
search. Parents were selected using tournament selection.
Crossover and two variants of the mutation operator were
used. The first mutation operator was aimed at reducing the
hard constraint cost while the second at improving timetable
quality.
2012 Fourth World Congress on Nature and Biologically Inspired Computing (NaBIC)
99
The following section describes the GA implemented in
this study and section V presents the GP approach used.
IV.
GA FOR SOLVING THE STP
This section describes the GA implemented to solve the
STP in terms of initial population generation, evaluation,
selection and genetic operators. The GA is generational and
is run for a set number of generations.
A. Initial Population Generation
Each element of the population is a timetable which is
represented using a two dimensional array where each row
represents a timeslot of the week and each column represents
a particular venue. Each cell in the matrix contains the tuple
indicating a class and a teacher. Figure 1 shows an example
of the timetable structure. Each lesson containing a class and
a teacher is allocated to a venue. Only one lesson is allocated
to a timeslot.
V1
V2
V3
V4
1
(C4,T4)
(C2,T3)
(C3,T2)
(C1,T1)
2
(C4,T3)
(C2,T2)
(C3,T4)
(C1,T1)
3
(C4,T3)
(C2,T2)
(C3,T1)
(C1,T4)
4
(C3,T1)
(C4,T2)
(C1,T4)
(C2,T3)
5
(C1,T2)
(C3,T1)
(C2,T4)
(C4,T3)
number of teacher clashes and venue clashes. The algorithm
in Figure 3 shows how the fitness of an individual is
calculated.
C. Selection
A sports tournament selection method was adopted for
choosing a parent. This selection method begins by randomly
selecting a group of individuals from the population with the
first individual being allocated “Champion” status. The
“Champion” then faces another competitor and the winner is
determined either by fitness or by chance. Every individual
selected has an opportunity to be “Champion”. Once all
individuals have been evaluated, the individual with the
status of “Champion” is selected as a parent. The algorithm
describing the sports tournament selection is illustrated in
Figure 4.
SumClashes = 0
For every timeslot in the timetable,
{
RowClashes = number of class or teacher
repetitions
SumClashes = SumClashes + RowClashes
}
Unscheduled = number of unscheduled class-teacher
meetings
Sum = SumClashes + Unscheduled
Return (Sum)
Figure 1: Timetable structure
Figure 3. Algorithm for fitness evaluation
An initial timetable is generated using a saturation degree
heuristic i.e. the tuples with the fewest feasible timeslots are
allocated first. Each individual in the initial population is
created using a sequential construction method (SCM). The
SCM generates a set of timetables and the fittest of these
individuals is added to the initial population. The algorithm
for creating the initial population is shown below in Figure 2.
Winner = Random individual from population
For J = 2 to TournamentSize
{
Opponent = Random individual from population
RandomNumber = Choose a random integer from 1
to 3
If (RandomNumber = 1)
Winner = fitter of individuals between
Winner and Opponent
Else if (RandomNumber = 2)
Winner = Opponent
Else
Winner is unchanged
}
For J = 0 to PopulationSize
{
For S = 0 to SCMSize
{
Create a timetable using saturation degree
Store timetable in SCMGroup
}
Add best timetable from SCMGroup to initial
population
}
Figure 2. Algorithm for initial population generation
B. Fitness Evaluation
In this study the Abramson data set is used to test the GA
and GP approaches. The constraints for the Abramson set of
problems are that all requirements must be met, i.e. all classteacher meetings must be scheduled and there must be no
teacher clashes, venue clashes or class clashes. The structure
of the timetable allows for the constraint regarding venues to
be satisfied i.e. no venue clashes are possible. The fitness
function counts the number of unscheduled meetings and the
100
Figure 4. Sports tournament selection
D. Genetic operators
Four mutation operators were tested for regeneration:
•
•
•
1V -Searches for a tuple resulting in a constraint
violation and swaps it with a randomly chosen tuple.
1VH - Is similar to 1V mutation operator but
incorporates hill climbing by only accepting swaps that
improve the fitness of the timetable.
2V - Searches for two constraint violating tuples and
swaps them.
2012 Fourth World Congress on Nature and Biologically Inspired Computing (NaBIC)
•
2VH - Is similar to the 2V mutation operator but
incorporates hill climbing.
Each mutation operator performs a set number of swaps,
thus allowing for the possibility that several improvements
could be made to the timetable in one operation. After
extensive testing it was found that the genetic algorithm
using the 2V operator performed the best as it produced the
most number of feasible timetables.
V.
GP FOR THE STP
This section describes the genetic programming approach
implemented to solve the school timetabling problem. The
following sections describe the processes of initial
population generation, evaluation and selection and the
genetic operators employed.
A. Initial population generation
Each program is represented as a combination of moves
or operators. Each character in the combination represents
one of six operators. The operators are described in Table 1.
The operator A inserts an unallocated tuple to the timetable.
D removes a tuple from the timetable. This tuple can then
be allocated again when A is applied. The four mutation
operators (labeled 1, 2, 3 and 4) are the four operators used
by the genetic algorithm described in Section 4. Each
mutation operator performs a set number of swaps.
Table 1. Operator set
Operator
A
D
1
2
3
4
Description
Allocate a tuple to the timetable
De-allocate a tuple from the timetable
One violation mutation (1V)
One violation mutation with hill
climbing (1VH)
Two violation mutation (2V)
Two violation mutation with hill
climbing (2VH)
An example of a program is D1A2A4. In this case the
first two operators will have no effect as the timetable is
blank and tuples will only be allocated by the third operator
in the program. Each element of the combination is
randomly selected. The maximum size of each program is a
multiple of the number of tuples to be allocated for the
particular problem instance. In this study trial runs have
shown that four times the number of tuples is sufficient.
B. Fitness Evaluation and Selection
The fitness of each individual of the population is
calculated by using the program to create a timetable. The
fitness measure of each program is the sum of the number of
clashes and unallocated tuples.
Tournament selection is used to choose parents. A group
of individuals, called the tournament, are randomly chosen
from the population and the fittest individual is selected as a
parent.
C. Genetic operators
The mutation and crossover genetic operators were used.
For mutation, a single character (operator) in a string is
randomly selected and replaced by another randomly chosen
character. An example of the mutation operator is shown in
Figure 5. In the example, the randomly selected operator A
has been replaced by mutation operator 3.
Initial string:
AD123AAD3421
(Mutation point underlined)
Mutated string:
AD1233AD3421
(Operator A replaced by mutation operator 3)
Figure 5. Example of mutation
An example of the crossover operator is shown below in
Figure 6.
Initial string (parent 1):
AD123AAD3421
(Crossover point in underlined)
Initial string (parent 2):
AD34ADAD321A
(Crossover point in underlined)
----------------------------------------------------------------Resultant child 1:
AD12D321A
Resultant child 2:
AD34ADA3AAD3421
Figure 6. Example of crossover
In the diagram above, a single crossover point was
randomly chosen for each parent. The first resultant child is
formed by combining the first part of parent 1 (i.e. the
characters before and including the selected crossover point)
with the second part of parent 2 (i.e. the characters after the
crossover point). Similarly, the second child is formed by
combining the first part of parent 2 and the second part of
parent 1. The crossover operation illustrated above implies
that the string length of the two resulting children could
differ i.e. the string length of child 1 could be longer than
the string length of child 2.
VI.
EXPERIMENTAL SETUP
The genetic algorithm and the GP approach described in
sections 4 and 5 respectively were applied to a set of
benchmark problems made available by Abramson [2].
Table 2 lists the characteristics of each problem. The only
constraints for this problem are that all class-teacher
meetings must be scheduled and there must be no class,
teacher or venue clashes. These benchmark problems have
been described as “hard” problems by Smith et al. [6] since
all tuples must be allocated and every timeslot in the
timetable must be used.
2012 Fourth World Congress on Nature and Biologically Inspired Computing (NaBIC)
101
Table 2: Characteristics of the benchmark problems
Problem
HDTT4
HDTT5
HDTT6
HDTT7
HDTT8
Number
of
classes
4
5
6
7
8
Number
of
teachers
4
5
6
7
8
Number
of
venues
4
5
6
7
8
Number
of
periods
30
30
30
30
30
Tuples
to
allocate
120
150
180
210
240
Due to the stochastic nature of these methods and to
ascertain statistical significance, thirty runs of both the GA
and GP were performed for each problem. A different seed
value for the random number generator was used for each
run. The genetic algorithm and genetic programming
algorithm were implemented in C++ and developed using
Microsoft Visual Studio 2008 and 2010 respectively.
Table 3 lists the genetic parameter values used for the
genetic algorithm. These values were obtained via a fine
tuning process.
Table 3: Parameter values for the genetic algorithm
Parameter
SCM size
Population Size
Tournament Size
Number of mutation swaps
Maximum number of generations
Value
50
1001
10
200
50
Table 4 lists the genetic parameters and their associated
values used for GP. These values were obtained empirically
by performing trial runs.
Table 4: Parameter values for the genetic program
Parameter
Population Size
Tournament Size
Number of swap for each mutation
operator
Maximum number of generations
Mutation Rate
Crossover Rate
Value
500
15
1000
50
20
80
VII. RESULTS AND DISCUSSION
Both the GA and genetic programming were able to
produce feasible solutions to all five problems. Table 5
shows the best and average cost obtained over the thirty
runs for each of the problems. Note that the cost is the sum
of the number of clashes and unallocated tuples.
Table 5: Best cost (BC) and average cost (AC) the GA and GP
GA
GP
102
HDTT4
BC: 0
AC: 0
BC: 0
AC: 0
HDTT5
BC: 0
AC: 0
BC: 0
AC: 0
HDTT6
BC: 0
AC: 0
BC: 0
AC: 0
HDTT7
BC: 0
AC: 1.07
BC: 0
AC: 0
HDTT8
BC: 0
AC: 1.73
BC: 0
AC: 0.2
For data sets HDTT4, HDTT5 and HDTT6, both the
genetic algorithm and GP found feasible timetables for all
runs. Genetic programming does perform better than the
genetic algorithm when applied to data sets HDTT7 and
HDTT8. Thus, GP appears to scale much better than the
GA. Furthermore, the results from Table 5 show that GP is
able to produce timetables with fewer constraint violations
on average than when using a genetic algorithm. In order to
confirm this, hypothesis tests were conducted to determine
the significance of this result. Table 6 lists the levels of
significance, critical values and decision rules for the
hypothesis tests.
Table 6: Levels of significance, critical values and decision rules
P
0.01
0.05
0.1
Critical Value
2.33
1.64
1.28
Decision rule
Reject H0 if Z > 2.33
Reject H0 if Z > 1.64
Reject H0 if Z > 1.28
The hypothesis tested for HDTT7 and HDTT8 and the
corresponding Z-values are shown in Table 7 below.
Table 7: Hypothesis and Z value for HDTT7 and HDTT8
Hypothesis
H0: μGA = μGP;
HA: μGA > μGP
H0: μGA = μGP;
HA: μGA > μGP
Data set
Z value
HDTT7
5.76
HDTT8
9.10
The Z values above indicate that the hypothesis that GP
performs better than the genetic algorithm is significant at
all levels of significance. These results could indicate that
for smaller data sets, genetic algorithms would work well
but genetic programming could be used to solve larger
timetable problems with more constraints.
Table 8 compares the performance of the genetic
algorithm and GP to that of other methods used to solve the
same benchmark problems. The methods included are:
• SA1 – The simulated annealing algorithm used by
Abramson et al. [2].
• SA2 – The simulated annealing algorithm implemented
by Randall et al. [4].
• TS – The tabu search used by Randall et al. [4].
• GS – A greedy search implemented by Randall et al.
[4].
• NN-T2 – A discrete Hopfield neural network,
developed by Smith et al. [6].
• NN-T3 – A second discrete Hopfield neural network,
implemented by Smith et al. [6].
• SA3 – A simulated annealing approach developed by
Liu et al. [11]
• Hybrid – A hybrid method using simulated annealing
and a VLSN algorithm implemented by Avella et al.
[7].
2012 Fourth World Congress on Nature and Biologically Inspired Computing (NaBIC)
An overview of these methods is provided in section II.
Table 8 displays the best cost and the average cost of
timetables for each of the studies. The details of this study
are listed in the columns labeled GA and GP. The average
cost (AC) indicates the average number of constraint
violations over all the runs while the best cost (BC)
indicates the best cost found out of all the runs. It must be
noted that only six runs were performed for the SA1
algorithm while twenty runs were performed for all the
other studies. Thirty runs were conducted for the genetic
algorithm and GP but in order to be consistent with the
other techniques, only the first twenty runs are considered in
Table 8 below.
Table 8: The best cost (BC) and average cost (AC) for each
method
SA1
SA2
TS
GS
NNTT2
NNTT3
SA3
Hybrid
GA
GP
HDTT4
Best: AC: -
HDTT5
Best: 0
AC: 0.67
HDTT6
Best: 0
AC: 2.5
HDTT7
Best :2
AC: 2.5
Best: 0
AC: 0
Best: 0
AC: 0.2
Best: 0
AC: 0.3
Best: 0
AC: 2.2
Best: 0
AC: 0.8
Best: 3
AC: 5.6
Best: 5
AC: 8.5
Best: 11
AC: 16.2
Best: 0
AC: 0.1
Best: 0
AC: 0.5
Best: 0
AC: 0
Best: 0
AC: 0
Best: 0
AC: 0
Best: 0
AC: 0.5
Best: 0
AC: 0.5
Best: 0
AC: 0
Best: 0
AC: 0
Best: 0
AC: 0
Best: 19
AC:
22.2
Best: 0
AC: 0.8
Best: 0
AC: 0.7
Best: 0
AC: 0
Best: 0
AC: 0
Best: 0
AC: 0
Best: 0
AC: 0
Best: 0
AC: 0
Best: 0
AC: 0
Best: 0
AC: 1.2
Best: 4
AC:
10.9
Best: 26
AC:
30.9
Best: 0
AC: 1.1
Best: 0
AC: 1
Best: 0
AC: 0
Best: 0
AC: 0.1
Best: 0
AC:
1.07
Best: 0
AC: 0
HDTT8
Best: 2
AC:
8.23
Best: 0
AC: 1.9
Best: 13
AC:
17.2
Best: 29
AC:
35.4
Best: 0
AC: 1.4
Best: 0
AC: 1.2
Best: 0
AC: 0.4
Best: 0
AC: 0.6
Best: 0
AC:
1.70
Best: 0
AC: 0
As can be seen from Table 8 above, the performance of
the genetic algorithm is competitive when compared to the
other techniques. GP performs the best, finding feasible
timetables for all 20 runs conducted for each data set.
VIII. CONCLUSION AND FUTURE WORK
This study compared the performance of genetic
algorithms and genetic programming in solving the school
timetabling problem. GP, which evolved programs for
creating timetabling solutions, was found to generally
produce better results and scale better than genetic
algorithms in solving the STP.
One of the main limitations found with GP was the
computational time needed to evolve a solution program.
While it took between 2 minutes and 15 minutes to find a
solution for the smaller datasets, when applying GP to
datasets HDTT7 and HDTT8, the time taken ranged from 90
minutes to 18 hours. This can be anticipated as the fitness of
each program is calculated by executing it to create a
timetable. This run time is much higher but must be
weighed against a success rate of more than 90%.
Future studies will look at using genetic programming to
solve larger school timetabling problems with both hard and
soft constraints as well as parallelizing the GP approach.
REFERENCES
[1]
[2]
[3]
[4]
[5]
[6]
[7]
[8]
[9]
[10]
[11]
[12]
[13]
A. Schaerf, "Tabu Search Techniques for Large High-School
Timetabling Problems", IEEE Transactions on Systems Management
and Cybernetics, 1996, pp. 363-368.
D. Abramson, "Constructing School Timetables using Simulated
Annealing:
Sequential and Parallel Algorithms", Management
Science, vol. 37, no. 1, 1991, pp. 98-113.
Y. Liu, D. Zhang, S.C.H. Leung, "A Simulated Annealing Approach
with a New Neighbourhood Structure for theTimetabling Problem",
Proceedings of GEC 2009, First ACM/SIGEVO Summit on Genetic
and Evolutionary Computing. July 2009, pp. 381-386.
M. Randall, D. Abramson, and C. Wild, “A Meta-Heuristic
BasedSolver for Combinatorial Optimization Problems”, Technical
Report,TR99-01, School of Information Technology, Bold
University,Australia, 1999.
G. N. Beligiannis, I. X. Tassopoulos, "Solving Effectively the School
Timetabling Problem using Particle Swarm Optimization", Expert
Systems with Applications, 39, 2012, pp. 6029-6040.
K. Smith, D. Abramson, D. Duke, "Hopfield Neural Networks for
Timetabling: Formulations, Methods and Comparitive Timetabling",
Computers and Industrial Engineering, 2003, pp. 283-305.
P. Avella,,B. D’Auria, S. Salerno, I. Vasil’ev, "A Computational
Study of Local Search Algorithms for Italian high-school
Timetabling", Journal of Heuristics, vol. 13, no 6, pp. 543-556.
J. Holland, Adaptation in Natural and Artificial Systems. The
University of Michigan Press: Ann Arbor. Michigan, 1975.
W. Banzhaf, P. Nordin, R. Keller, F. D. Francone. Genetic
Programming. "An Introduction on the Automatic Evolution of
Computer Programs and its Applications". Morgan Kaufmann
Publishers Inc, 1998.
C. F. Bedoya, M. Santos, "A Non-Standard Genetic Algorithm
Approach to Solve Constrained School Timetabling Problems",
Computer Aided Systems Theory – Eurocast 2003, Lecture Notes in
Computer Science, vol. 2809, 2003, pp. 26-37.
D. Abramson, J. Abela, " A Parallel Genetic Algorithm for Solving
the School Timetabling Problem", Proceedings of the 15th Australian
Conference: Division of Information Technology, 1991, pp. 1-11.
G. N. Beligiannis, C. N. Moschopoulos, G. P. Kaperonis, S. D.
Likothanassis, S.D., "Applying Evolutionary Computation to the
School Timetabling Problem: The Greek Case", Computers and
Operations Research, vol. 35., 2008, pp. 1265-1280.
C. Di Stefano, A.G.B. Tettamanzi, "An Evolutionary Algorithm for
Solving the School Timetabling Problem", Applications of
Evolutionary Computing. Lecture Notes in Computer Science, 2001,
vol 2037, pp. 452-462.
2012 Fourth World Congress on Nature and Biologically Inspired Computing (NaBIC)
103