17 research outputs found
The AllDifferent Constraint with Precedences
We propose ALLDIFFPREC, a new global constraint that combines together an ALLDIFFERENT constraint with precedence constraints that strictly order given pairs of variables. We identify a number of applications for this global constraint including instruction scheduling and symmetry breaking. We give an efficient propagation algorithm that enforces bounds consistency on this global constraint. We show how to implement this propagator using a decomposition that extends the bounds consistency enforcing decomposition proposed for the ALLDIFFERENT constraint. Finally, we prove that enforcing domain consistency on this global constraint is NP-hard in general
Linear-time filtering algorithms for the disjunctive constraint and a quadratic filtering algorithm for the cumulative not-first not-last
We present new filtering algorithms for Disjunctive and Cumulative
constraints, each of which improves the complexity of the state-of-theart
algorithms by a factor of log n. We show how to perform TimeTabling
and Detectable Precedences in linear time on the Disjunctive
constraint. Furthermore, we present a linear-time Overload Checking for
the Disjunctive and Cumulative constraints. Finally, we show how
the rule of Not-first/Not-last can be enforced in quadratic time for the
Cumulative constraint. These algorithms rely on the union find data
structure, from which we take advantage to introduce a new data structure
that we call it time line. This data structure provides constant time
operations that were previously implemented in logarithmic time by the
Θ-tree data structure. Experiments show that these new algorithms are
competitive even for a small number of tasks and outperform existing algorithms
as the number of tasks increases. We also show that the time
line can be used to solve specific scheduling problems
When do bounds and domain propagation lead to the same search space
This paper explores the question of when two propagation-based constraint systems have the same behaviour, in terms of search space. We categorise the behaviour of domain and bounds propagators for primitive constraints, and provide theorems that allow us to determine propagation behaviours for conjunctions of constraints. We then show how we can use this to analyse CLP(FD) programs to determine when we can safely replace domain propagators by more efficient bounds propagators without increasing search space
Solving finite-domain linear constraints in presence of the
In this paper, we investigate the possibility of improvement of the
widely-used filtering algorithm for the linear constraints in constraint
satisfaction problems in the presence of the alldifferent constraints. In many
cases, the fact that the variables in a linear constraint are also constrained
by some alldifferent constraints may help us to calculate stronger bounds of
the variables, leading to a stronger constraint propagation. We propose an
improved filtering algorithm that targets such cases. We provide a detailed
description of the proposed algorithm and prove its correctness. We evaluate
the approach on five different problems that involve combinations of the linear
and the alldifferent constraints. We also compare our algorithm to other
relevant approaches. The experimental results show a great potential of the
proposed improvement.Comment: 28 pages, 2 figure
Computing leximin-optimal solutions in constraint networks
AbstractIn many real-world multiobjective optimization problems one needs to find solutions or alternatives that provide a fair compromise between different conflicting objective functions—which could be criteria in a multicriteria context, or agent utilities in a multiagent context—while being efficient (i.e. informally, ensuring the greatest possible overall agents' satisfaction). This is typically the case in problems implying human agents, where fairness and efficiency requirements must be met. Preference handling, resource allocation problems are another examples of the need for balanced compromises between several conflicting objectives. A way to characterize good solutions in such problems is to use the leximin preorder to compare the vectors of objective values, and to select the solutions which maximize this preorder. In this article, we describe five algorithms for finding leximin-optimal solutions using constraint programming. Three of these algorithms are original. Other ones are adapted, in constraint programming settings, from existing works. The algorithms are compared experimentally on three benchmark problems
Faster Algorithms for Bound-Consistency of the Sortedness and the Alldifferent Constraint
We present narrowing algorithms for the sortedness and the alldifferent constraint which achieve bound-consistency. The algorithm for the sortedness constraint takes as input 2n intervals X1 , ..., Xn , Y1 , ..., Yn from a linearly ordered set D. Let S denote the set of all tuples t 2 X1 Xn Y1 Yn such that the last n components of t are obtained by sorting the first n components. Our algorithm determines whether S is non-empty and if so reduces the intervals to bound-consistency. The running time of the algorithm is asymptotically the same as for sorting the interval endpoints. In problems where this is faster than O(n log n), this improves upon previous results. The algorithm for the alldifferent constraint takes as input n integer intervals Z1 , ..., Zn . Let T denote all tuples t 2 Z1 Zn where all components are pairwise different. The algorithm checks whether T is non-empty and if so reduces the ranges to bound-consistency. The running time is also asymptotically the same as for sorting the interval endpoints. When the constraint is for example a permutation constraint, i.e. Z i [1; n] for all i, the running time is linear. This also improves upon previous results
Efficient algorithms to solve scheduling problems with a variety of optimization criteria
La programmation par contraintes est une technique puissante pour résoudre, entre autres, des problèmes d'ordonnancement de grande envergure. L'ordonnancement vise à allouer dans le temps des tâches à des ressources. Lors de son exécution, une tâche consomme une ressource à un taux constant. Généralement, on cherche à optimiser une fonction objectif telle la durée totale d'un ordonnancement. Résoudre un problème d'ordonnancement signifie trouver quand chaque tâche doit débuter et quelle ressource doit l'exécuter. La plupart des problèmes d'ordonnancement sont NP-Difficiles. Conséquemment, il n'existe aucun algorithme connu capable de les résoudre en temps polynomial. Cependant, il existe des spécialisations aux problèmes d'ordonnancement qui ne sont pas NP-Complet. Ces problèmes peuvent être résolus en temps polynomial en utilisant des algorithmes qui leur sont propres. Notre objectif est d'explorer ces algorithmes d'ordonnancement dans plusieurs contextes variés. Les techniques de filtrage ont beaucoup évolué dans les dernières années en ordonnancement basé sur les contraintes. La proéminence des algorithmes de filtrage repose sur leur habilité à réduire l'arbre de recherche en excluant les valeurs des domaines qui ne participent pas à des solutions au problème. Nous proposons des améliorations et présentons des algorithmes de filtrage plus efficaces pour résoudre des problèmes classiques d'ordonnancement. De plus, nous présentons des adaptations de techniques de filtrage pour le cas où les tâches peuvent être retardées. Nous considérons aussi différentes propriétés de problèmes industriels et résolvons plus efficacement des problèmes où le critère d'optimisation n'est pas nécessairement le moment où la dernière tâche se termine. Par exemple, nous présentons des algorithmes à temps polynomial pour le cas où la quantité de ressources fluctue dans le temps, ou quand le coût d'exécuter une tâche au temps t dépend de t.Constraint programming is a powerful methodology to solve large scale and practical scheduling problems. Resource-constrained scheduling deals with temporal allocation of a variety of tasks to a set of resources, where the tasks consume a certain amount of resource during their execution. Ordinarily, a desired objective function such as the total length of a feasible schedule, called the makespan, is optimized in scheduling problems. Solving the scheduling problem is equivalent to finding out when each task starts and which resource executes it. In general, the scheduling problems are NP-Hard. Consequently, there exists no known algorithm that can solve the problem by executing a polynomial number of instructions. Nonetheless, there exist specializations for scheduling problems that are not NP-Complete. Such problems can be solved in polynomial time using dedicated algorithms. We tackle such algorithms for scheduling problems in a variety of contexts. Filtering techniques are being developed and improved over the past years in constraint-based scheduling. The prominency of filtering algorithms lies on their power to shrink the search tree by excluding values from the domains which do not yield a feasible solution. We propose improvements and present faster filtering algorithms for classical scheduling problems. Furthermore, we establish the adaptions of filtering techniques to the case that the tasks can be delayed. We also consider distinct properties of industrial scheduling problems and solve more efficiently the scheduling problems whose optimization criteria is not necessarily the makespan. For instance, we present polynomial time algorithms for the case that the amount of available resources fluctuates over time, or when the cost of executing a task at time t is dependent on t
Models and Algorithms for School Timetabling
In constraint programming, combinatorial problems are specified
declaratively in terms of constraints. Constraints are relations over
problem variables that define the space of solutions by specifying
restrictions on the values that variables may take simultaneously. To
solve problems stated in terms of constraints, the constraint
programmer typically combines chronological backtracking with
constraint propagation that identifies infeasible value combinations
and prunes the search space.
In recent years, constraint programming has emerged as a key
technology for combinatorial optimization in industrial
applications. In this success, global constraints have been playing a
vital role. Global constraints are carefully designed abstractions
that, in a concise and natural way, allow to model problems that arise
in different fields of application. For example, the alldiff
constraint allows to state that variables must take pairwise distinct
values; it has numerous applications in timetabling and scheduling.
In school timetabling, we are required to schedule a given set of
meetings between students and teachers s.t. the resulting timetables
are feasible and acceptable to all people involved. Since schools
differ in their educational policies, the school-timetabling problem
occurs in several variations. Nevertheless, a set of entities and
constraints among them exist that are common to these variations. This
common core still gives rise to NP-complete combinatorial problems.
In the first place, this thesis proposes to model the common core of
school-timetabling problems by means of global constraints. The
presentation continues with a series of operational enhancements to
the resulting problem solver which are grounded on the "track
parallelization problem" (TPP). A TPP is specified by a set of task
sets which are called "tracks". The problem of solving a TPP
consists in scheduling the tasks s.t. the tracks are processed in
parallel. We show how to infer TPPs in school timetabling and we
investigate two ways of TPP propagation: On the one hand, we utilize
TPPs to down-size our models. On the other hand, we propagate TPPs to
prune the search space. To this end, we introduce the TPP
constraint along with a suitable constraint solver for modeling and
solving TPPs in a finite-domain constraint programming framework.
To investigate our problem solvers' behavior, we performed a
large-scale empirical study. When designing the experiment, the top
priority was to obtain results that are both reliable from a
statistical point of view and practically relevant. To this end, the
sample sizes have been chosen accordingly - for each school, our
problem set contains 1000 problems - and the problems have been
generated from detailed models of ten representative schools. Our
timetabling engine essentially embeds network-flow techniques and
value sweep pruning into chronological backtracking