Finding optimal solutions to the graph partitioning problem with heuristic search

As search spaces become larger and as problems scale up, an efficient way to speed up the search is to use a more accurate heuristic function. A better heuristic function might be obtained by the following general idea. Many problems can be divided into a set of subproblems and subgoals that should be achieved. Interactions and conflicts between unsolved subgoals of the problem might provide useful knowledge which could be used to construct an informed heuristic function. In this paper we demonstrate this idea on the graph partitioning problem (GPP). We first show how to format GPP as a search problem and then introduce a sequence of admissible heuristic functions estimating the size of the optimal partition by looking into different interactions between vertices of the graph. We then optimally solve GPP with these heuristics. Experimental results show that our advanced heuristics achieve a speedup of up to a number of orders of magnitude. Finally, we experimentally compare our approach to other states of the art graph partitioning optimal solvers on a number of classes of graphs. The results obtained show that our algorithm outperforms them in many cases.     

Smoothed Analysis of Partitioning Algorithms for Euclidean Functionals

Euclidean optimization problems such as TSP and minimum-length matching admit fast partitioning algorithms that compute near-optimal solutions on typical instances. In order to explain this performance, we develop a general framework for the application of smoothed analysis to partitioning algorithms for Euclidean optimization problems. Our framework can be used to analyze both the running-time and the approximation ratio of such algorithms. We apply our framework to obtain smoothed analyses of Dyer and Frieze’s partitioning algorithm for Euclidean matching, Karp’s partitioning scheme for the TSP, a heuristic for Steiner trees, and a heuristic for degree-bounded minimum-length spanning trees.     

Experiments on drawing 2-level hierarchical graphs

This paper studies different heuristics for drawing 2-level hierarchical graphs. Especially, we compare the barycenter and the median heuristics. We show that the barycenter heuristic clearly outperforms the median heuristic, although only the latter has a proved bound for the maximum error done when two vertices are ordered. Moreover, we improve a known heuristic, called the greedy switching, by introducing the barycenter heuristic as a preprocessing phase for it.     

The application of single-pass heuristics for U-lines

U-lines have been adopted in many manufacturing settings as part of JIT implementation. In this paper, we examine the applicability of existing straight-line heuristics for obtaining a balance on a U-line. We modify 13 single-pass heuristics and study the effectiveness of various heuristics under different problem conditions. An extensive computational study is carried out to help identify the best heuristics. In addition, we compare recent U-line procedures with a single-pass heuristic using some literature problems. Based on a single-pass heuristic, we compare the configurations of a straight- and U-line.     

The three-stage assembly flowshop scheduling problem

We consider the three-stage assembly flowshop scheduling problem with the objective of minimizing the makespan. The three-stage assembly problem generalizes both the serial three machine flowshop problem and the two-stage assembly flowshop scheduling problem and is therefore strongly NP-hard. We analyze the worst-case ratio bound for several heuristics for this problem. We also analyze the worst-case absolute bound for a heuristic based on compact vector summation techniques and we point out that, for a large number of jobs, this heuristic becomes asymptotically optimal.Scope and purposeThe three-stage assembly flowshop scheduling problem models situations which arise frequently in manufacturing when various fabrication operations are performed concurrently and then collected and transported into an assembly area for a final assembly operation. The main criterion for this problem is the minimization of the maximum job completion time (makespan). The objective of this paper is to derive algorithms for minimizing the makespan. In doing so, we also demonstrate the reduction of assembly flowshop problems to their embedded serial flowshop problems.     

二元约束满足问题求解的结点开销模型

提出了在二元约束满足问题中以搜索结点个数为衡量标准的求解开销模型,该模型被应用于随机二元约束满足问题的求解开销相变分析中,并且比较了模型所导出的理论开销和实际中的搜索结点个数、约束检查次数、求解时间3种衡量标准的开销之间的相似性.在模型的基础上，探讨了求解启发式减少求解开销的作用，给出了一个新的变量选择启发式.     

On look-ahead heuristics in disjunctive logic programming

Disjunctive logic programming (DLP), also called answer set programming (ASP), is a convenient programming paradigm which allows for solving problems in a simple and highly declarative way. The language of DLP is very expressive and able to represent even problems of high complexity (every problem in the complexity class ${{\Sigma}_{2}^{P}} = {\rm NP}^{{\rm NP}}$ ). During the last decade, efficient systems supporting DLP have become available. Virtually all of these systems internally rely on variants of the Davis–Putnam procedure (for deciding propositional satisfiability [SAT]), combined with a suitable model checker. The heuristic for the selection of the branching literal (i.e., the criterion determining the literal to be assumed true at a given stage of the computation) dramatically affects the performance of a DLP system. While heuristics for SAT have received a fair deal of research, only little work on heuristics for DLP has been done so far. In this paper, we design, implement, optimize, and experiment with a number of heuristics for DLP. We focus on different look-ahead heuristics, also called “dynamic heuristics” (the DLP equivalent of unit propagation [UP] heuristics for SAT). These are branching rules where the heuristic value of a literal Q depends on the result of taking Q true and computing its consequences. We motivate and formally define a number of look-ahead heuristics for DLP programs. Furthermore, since look-ahead heuristics are computationally expensive, we design two techniques for optimizing the burden of their computation. We implement all the proposed heuristics and optimization techniques in DLV—the state-of-the-art implementation of disjunctive logic programming, and we carry out experiments, thoroughly comparing the heuristics and optimization techniques on a large number of instances of well-known benchmark problems. The results of these experiments are very interesting, showing that the proposed techniques significantly improve the performance of the DLV system.     

New heuristics for planning operating rooms

We tackle the operating room planning problem of the Plastic Surgery and Major Burns Specialty of the University Hospital “Virgen del Rocio” in Seville (Spain). The decision problem is to assign an intervention date and an operating room to a set of surgeries on the waiting list, minimizing access time for patients with diverse clinical priority values. This problem has been previously addressed in the literature considering different objective functions. The clinical priority depends on the surgery priority and the number of days spent on the waiting list. We propose a set of 83 heuristics (81 constructive heuristics, a composite heuristic, and a meta-heuristic) based on a new solution encoding, and we compare these methods against existing heuristics from the literature for solving operating room planning problems. The heuristics are adapted to the problem under consideration (i.e. considering all constraints and the new objective function), being re-implemented using the information provided by the authors. In total, after a calibration procedure, we compare 17 heuristics. The computational experiments show that our proposed meta-heuristic is the best for the problem under consideration. Finally, the proposed heuristics are tested using data from the Plastic Surgery and Major Burns Specialty. The results show significant improvements on several key performance indicators (number of scheduled surgeries, quality of surgical plan, resources utilization, etc.) when comparing with the actual results obtained by the specialty in the current practice. The aforementioned hospital is currently implementing the heuristic methods.     

Parallel Heuristics for Improved, Balanced Graph Colorings

The computation of good, balanced graph colorings is an essential part of many algorithms required in scientific and engineering applications. Motivated by an effective sequential heuristic, we introduce a new parallel heuristic, PLF, and show that this heuristic has the same expected runtime under the PRAM computational model as the scalable coloring heuristic introduced by Jones and Plassmann. We present experimental results performed on the Intel DELTA that demonstrate that this new heuristic consistently generates better colorings and requires only slightly more time than the JP heuristic. In the second part of the paper we introduce two new parallel color-balancing heuristics, PDR(k) and PLF(k). We show that these heuristics have the desirable property that they do not increase the number of colors used by an initial coloring during the balancing process. We present experimental results that show that these heuristics are very effective in obtaining balanced colorings and, in addition, exhibit scalable performance.     

Heuristics for minimizing maximum lateness on a single machine with family-dependent set-up times

We address the problem of scheduling a single machine subject to family-dependent set-up times in order to minimize maximum lateness. We present a number of local improvement heuristics based on the work of previous researchers, a rolling horizon heuristic, and an incomplete dynamic programming heuristic. Extensive computational experiments on randomly generated test problems compare the performance of these heuristics. The rolling horizon procedures perform particularly well but require their parameters to be set based on problem characteristics to obtain their best performance.     

Problem reduction heuristic for the 0-1 multidimensional knapsack problem

This paper introduces new problem-size reduction heuristics for the multidimensional knapsack problem. These heuristics are based on solving a relaxed version of the problem, using the dual variables to formulate a Lagrangian relaxation of the original problem, and then solving an estimated core problem to achieve a heuristic solution to the original problem. We demonstrate the performance of these heuristics as compared to legacy heuristics and two other problem reduction heuristics for the multi-dimensional knapsack problem. We discuss problems with existing test problems and discuss the use of an improved test problem generation approach. We use a competitive test to highlight the performance of our heuristics versus the legacy heuristic approaches. We also introduce the concept of computational versus competitive problem test data sets as a means to focus the empirical analysis of heuristic performance.     

Sequential Monte Carlo in reachability heuristics for probabilistic planning

Some of the current best conformant probabilistic planners focus on finding a fixed length plan with maximal probability. While these approaches can find optimal solutions, they often do not scale for large problems or plan lengths. As has been shown in classical planning, heuristic search outperforms bounded length search (especially when an appropriate plan length is not given a priori). The problem with applying heuristic search in probabilistic planning is that effective heuristics are as yet lacking.In this work, we apply heuristic search to conformant probabilistic planning by adapting planning graph heuristics developed for non-deterministic planning. We evaluate a straight-forward application of these planning graph techniques, which amounts to exactly computing a distribution over many relaxed planning graphs (one planning graph for each joint outcome of uncertain actions at each time step). Computing this distribution is costly, so we apply Sequential Monte Carlo (SMC) to approximate it. One important issue that we explore in this work is how to automatically determine the number of samples required for effective heuristic computation. We empirically demonstrate on several domains how our efficient, but sometimes suboptimal, approach enables our planner to solve much larger problems than an existing optimal bounded length probabilistic planner and still find reasonable quality solutions.     

CSPs with counters: a likelihood-based heuristic

Abstract. Counter constraints are a naturalrepresentation of constraints on the finite capacity of resources in resource-allocation type problems. They are a generic family of non-binary constraints that limit the number of variables that may be assigned particular values. Counter constraints can be represented by binary constraints, at a cost. We analyse the cost, show how a counter can be represented as a linear number of binary constraints, and demonstrate empirically that even with the optimal reduction,an explicit representation of counters is preferable to their representation as a set of binary constraints. For counter constraints, value ordering is essential. An heuristic for value ordering on constraint satisfaction problems (CSP), based on the estimated likelihoodof a solution, is presented. The proposed value ordering heuristic is useful for counter constraints, as well as for binary CSPs, where it can be used to approximate the number of solutions consistent with a particular value assignment to a variable. The proposed value ordering heuristic integrates counter constraints with binary constraint networks in a novel manner. Counter constraints are problematic for most heuristics, which are local in scope, yet we demonstrated empirically that the proposed value ordering heuristic is significantly superior to heuristics used in previous work.     

An investigation of fuzzy multiple heuristic orderings in the construction of university examination timetables

In this paper, we present an investigation into using fuzzy methodologies to guide the construction of high quality feasible examination timetabling solutions. The provision of automated solutions to the examination timetabling problem is achieved through a combination of construction and improvement. The enhancement of solutions through the use of techniques such as metaheuristics is, in some cases, dependent on the quality of the solution obtained during the construction process. With a few notable exceptions, recent research has concentrated on the improvement of solutions as opposed to focusing on investigating the ‘best’ approaches to the construction phase. Addressing this issue, our approach is based on combining multiple criteria in deciding on how the construction phase should proceed. Fuzzy methods were used to combine three single construction heuristics into three different pair wise combinations of heuristics in order to guide the order in which exams were selected to be inserted into the timetable solution. In order to investigate the approach, we compared the performance of the various heuristic approaches with respect to a number of important criteria (overall cost penalty, number of skipped exams, number of iterations of a rescheduling procedure required and computational time) on 12 well-known benchmark problems. We demonstrate that the fuzzy combination of heuristics allows high quality solutions to be constructed. On one of the 12 problems, we obtained lower penalty than any previously published constructive method and for all 12 we obtained lower penalty than when any of the single heuristics were used alone. Furthermore, we demonstrate that the fuzzy approach used less backtracking when constructing solutions than any of the single heuristics. We conclude that this novel fuzzy approach is a highly effective method for heuristically constructing solutions and, as such, has particular relevance to real-world situations in which the construction of feasible solutions is often a difficult task in its own right.     

Heuristics for scheduling file-sharing tasks on heterogeneous systems with distributed repositories

We consider the problem of scheduling an application on a computing system consisting of heterogeneous processors and data repositories. The application consists of a large number of file-sharing otherwise independent tasks. The files initially reside on the repositories. The processors and the repositories are connected through a heterogeneous interconnection network. Our aim is to assign the tasks to the processors, to schedule the file transfers from the repositories, and to schedule the executions of tasks on each processor in such a way that the turnaround time is minimized. We propose a heuristic composed of three phases: initial task assignment, task assignment refinement, and execution ordering. We experimentally compare the proposed heuristics with three well-known heuristics on a large number of problem instances. The proposed heuristic runs considerably faster than the existing heuristics and obtains 10–14% better turnaround times than the best of the three existing heuristics.     

Shipment partitioning and routing to minimize makespan in a transportation network

This paper addresses the problem of partitioning and transporting a shipment of known size through an n-node public transportation network with known scheduled departure and arrival times and expected available capacities for each departure. The objective is to minimize the makespan of shipping. The problem while practical in its scope, has received very little attention in the literature perhaps because of the concentration of research in vehicle routing without regard to partitioning and partitioning without regard to routing. A general non-linear programming model is developed. The model is then converted into a linear model through the Routing First and Assignment Second approach. This approach is different from the general decomposition approaches since they normally do not guarantee optimality. However, the linear model still involves a large number of constraints, and solution is not attempted here. Instead, three heuristics are proposed for solving the problem. Two of the heuristics use iterative techniques to evaluate all possible paths. The third heuristic uses a max-flows approach based upon aggregated capacities to reduce the size of the network presented to the other heuristics. This allows for a good starting point for other heuristics, and may impact the total computational effort. We find that the heuristics developed perform well because in the case of networks that are not congested, they find the optimal solution.     

A new directed branching heuristic for the pq-median problem

The pq-median problem, of Serra and ReVelle seeks to locate hierarchical facilities at two levels so as to obtain a coherent structure. Coherence requires that the entire area assigned to a facility at the inferior level be assigned to one and the same facility at the next higher level of the hierarchy. Although optimal solutions can be obtained by means of solving biobjective integer linear programs, large problems are likely to require heuristics. Here we present a new heuristic that combines the generation of points, by means of a “directed” branching procedure with the final selection of points, using the FDH-technique. We further compare our new heuristic with the two most relevant heuristics proposed by Serra and ReVelle.     

Scheduling algorithms for heterogeneous batch processors with incompatible job-families

We consider the problem of scheduling heterogeneous batch processors (i.e., batch processors with different capacity) with incompatible job-families and non-identical job sizes to maximize the utilization of the batch processors. We analyzed the computational complexity of this problem and showed that it is NP-hard and proposed eight variants of a fast greedy heuristic. A series of computational experiments were carried out to compare the performance of the heuristics and showed that the heuristics are capable of consistently obtaining near (estimated) optimal solutions with very low-computational burden for large-scale problems. We also carried out a study to find the effect of family processing time changes on the performance of the heuristics. This sensitivity analysis indicated that the processing time set of job-families influences the performance of the heuristic algorithms.     

Downward pattern refinement for timed automata

Directed model checking is a well-established approach for detecting error states in concurrent systems. A popular variant to find shortest error traces is to apply the A\(^*\) search algorithm with distance heuristics that never overestimate the real error distance. An important class of such distance heuristics is the class of pattern database heuristics. Pattern database heuristics are built on abstractions of the system under consideration. In this paper, we propose downward pattern refinement, a systematic approach for the construction of pattern database heuristics for concurrent systems of timed automata. First, we propose a general framework for pattern databases in the context of timed automata and show that desirable theoretical properties hold for the resulting pattern database. Afterward, we formally define a concept to measure the accuracy of abstractions. Based on this concept, we propose an algorithm for computing succinct abstractions that are still accurate to produce informed pattern databases. We evaluate our approach on large and complex industrial problems. The experiments show the practical potential of the resulting pattern database heuristic.     

Hybrid tabu search and a truncated branch-and-bound for the unrelated parallel machine scheduling problem

We consider the problem of scheduling a number of jobs on a number of unrelated parallel machines in order to minimize the makespan. We develop three heuristic approaches, i.e., a genetic algorithm, a tabu search algorithm and a hybridization of these heuristics with a truncated branch-and-bound procedure. This hybridization is made in order to accelerate the search process to near-optimal solutions. The branch-and-bound procedure will check whether the solutions obtained by the meta-heuristics can be scheduled within a tight upper bound. We compare the performances of these heuristics on a standard dataset available in the literature. Moreover, the influence of the different heuristic parameters is examined as well. The computational experiments reveal that the hybrid heuristics are able to compete with the best known results from the literature.