An information theoretic based integer linear programming approach for the discrete search path planning problem

A common strategic and tactical decision in open pit mining is to determine the sequence of extraction for notional three-dimensional production blocks so as to maximize the net present value of the extracted orebody while adhering to precedence and resource constraints. This problem is commonly formulated as an integer program with a binary variable representing if and when a block is extracted. In practical applications, the number of blocks can be large and the time horizon can be long, and therefore, instances of this NP-hard precedence-constrained knapsack problem can be difficult to solve using an exact approach. The problem is even more challenging to solve when it includes explicit minimum resource constraints. We employ three methodologies to reduce solution times: (i) we eliminate variables which must assume a value of 0 in the optimal solution; (ii) we use heuristics to generate an initial integer feasible solution for use by the branch-and-bound algorithm; and (iii) we employ Lagrangian relaxation, using information obtained while generating the initial solution to select a dualization scheme for the resource constraints. The combination of these techniques allows us to determine near-optimal solutions more quickly than solving the monolith, i.e., the original problem. We demonstrate our techniques to solve instances containing 25,000 blocks and 10 time periods, and 10,000 blocks and 15 time periods, to near-optimality.

: An algorithm is presented for the two duty period scheduling problem. This integer programming problem has a binary constraint matrix with two sets of consecutive ones in each column. At each subproblem of a branch and bound procedure, subgradient optimization is used to maximize the value of a Lagrangean relaxation, which is a network flow problem. The algorithm is implemented for the two duty period set partitioning problem, with shortest path relaxations. A second algorithm utilizing the unique properties of prime numbers is developed for solving small subproblems. Computational results are reported for several large problems. (Author)

The weighted independent domination problem: Integer linear programming models and metaheuristic approaches

The weighted maximal planar graph (WMPG) is practically important in the laying out of facilities in modern manufacturing environments. Given a weighted complete graph, the WMPG seeks to find a sub-graph such that it is planar—it can be embedded on the plane without any arcs intersecting, and it is maximal—no additional arc can be added to the sub-graph without destroying its planarity, and it also has the maximal sum of arc weights. In this paper, an integer linear programming (ILP) model is newly introduced for the problem. Two meta-heuristics are then derived from the ILP relaxation. The first meta-heuristic considers all variables with fractional values greater than half in the ILP relaxation to build an initial sub-graph from which a planar sub-graph is extracted using greedy random adaptive search procedure (GRASP) and augmented by triangulation of faces. The second meta-heuristic considers only arcs with integer values in the ILP relaxation. The remaining arcs are then sorted in descending order of their weights, for selection and insertion with a planarity testing procedure, to obtain a feasible solution using GRASP. Computational results are reported on a set of 100 test instances of size varying from 20 to 100 facilities. The computational results demonstrate the tightness of the new upper bound when compared to the classical one as well as the good performance of the proposed metaheuristics when compared to the best-known procedures in the literature in terms of solution quality and computational requirement. Finally, the paper presents a successful integration of GRASP with classical optimisation approaches and should be attempted for other optimisation problems.

Many fundamental NP-hard problems can be formulated as integer linear programs (ILPs). A famous algorithm by Lenstra solves ILPs in time that is exponential only in the dimension of the program, and polynomial in the size of the ILP. That algorithm became a ubiquitous tool in the design of fixed-parameter algorithms for NP-hard problems, where one wishes to isolate the hardness of a problemby some parameter. However, in many cases using Lenstra's algorithm has two drawbacks: First, the run time of the resulting algorithms is often doubly-exponential in the parameter, and second, an ILP formulation in small dimension cannot easily express problems involving many different costs. Inspired by the work of Hemmecke, Onn and Romanchuk [Math. Prog. 2013], we develop a single-exponential algorithm for so-called combinatorial n-fold integer programs, which are remarkably similar to prior ILP formulations for various problems, but unlike them, also allow variable dimension. We then apply our algorithm to a few representative problems like Closest String, Swap Bribery, Weighted Set Multicover, and obtain exponential speedups in the dependence on the respective parameters, the input size, or both. Unlike Lenstra's algorithm, which is essentially a bounded search tree algorithm, our result uses the technique of augmenting steps. At its heart is a deep result stating that in combinatorial n-fold IPs, existence of an augmenting step implies existence of a \local" augmenting step, which can be found using dynamic programming. Our results provide an important insight into many problems by showing that they exhibit this phenomenon, and highlights the importance of augmentation techniques.

We present new integer linear programming (ILP) models for NP-hard optimisation problems in instances of the Stable Marriage problem with Ties and Incomplete lists (SMTI) and its many-to-one generalisation, the Hospitals/Residents problem with Ties (HRT). These models can be used to efficiently solve these optimisation problems when applied to (i) instances derived from real-world applications, and (ii) larger instances that are randomly-generated. In the case of SMTI, we consider instances arising from the pairing of children with adoptive families, where preferences are obtained from a quality measure of each possible pairing of child to family. In this case, we seek a maximum weight stable matching. We present new algorithms for preprocessing instances of SMTI with ties on both sides, as well as new ILP models. Algorithms based on existing state-of-the-art models only solve 6 of our 22 real-world instances within an hour per instance, and our new models incorporating dummy variables and constraint merging, together with preprocessing and a warm start, solve all 22 instances within a mean runtime of a minute. For HRT, we consider instances derived from the problem of assigning junior doctors to foundation posts in Scottish hospitals. Here, we seek a maximum size stable matching. We show how to extend our models for SMTI to HRT and reduce the average running time for real-world HRT instances by two orders of magnitude. We also show that our models outperform by a wide margin all known state-of-the-art models on larger randomly-generated instances of SMTI and HRT.

<para xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink"> This paper deals with vehicle-scheduling problem (VSP) in an automatic material-handling environment in 300-mm semiconductor wafer manufacturing. We adopt Petri nets (PNs) modeling techniques to model the complicated coupling dynamics among transport jobs and overhead hoist transport (OHT) vehicles in a 300-mm OHT loop. The congestion phenomenon among OHT vehicles is captured. With help of the PN models, we formulate the OHT VSP as an integer programming problem whose objective is to schedule OHT vehicles to transport jobs such that average job completion time is minimized. Instead of solving for the optimal solution, we develop a solution methodology to generate a feasible schedule efficiently. A Lagrangian relaxation step is first taken to decompose the PN-based, integer programming problem into individual job-scheduling subproblems. To reduce computation efforts in solving each subproblem optimally, we develop an approximation method to solve each job subproblem by utilizing a reduced PN model of the job. Lagrangian multipliers are then optimized by a surrogate subgradient method. A heuristic algorithm is developed to adjust the dual solution to a feasible schedule. Numerical results demonstrate that our solution methodology can generate good schedules within a reasonable amount of computation time for realistic problems. Compared to a popular vehicle-dispatching rule, our approach can achieve in average 32% improvements on the average delivery time in our realistic test cases. </para>

Distributed data association in smart camera network via dual decomposition

The classical generalized assignment problem (GAP) may be stated as finding a minimum-cost assignment of tasks to agents such that each task is assigned to exactly one agent and such that each agent's resource capacity is honored. This NP-hard problem has applications that include job scheduling, routing, loading for flexible manufacturing systems, and facility location. Due to the difficulty in solving “hard” GAPs to optimality, most recent papers either describe heuristic methods for generating “good” solutions or, in the case of optimizing methods, computational results are limited to 500 to 1,000 binary variables. In this paper we describe a special purpose branch-and-bound algorithm that utilizes linear programming cuts, feasible-solution generators, Lagrangean relaxation, and subgradient optimization. We present computational results for solving “hard” problems with up to 3,000 binary variables. An unanticipated benefit of the algorithm is its ability to generate good feasible solutions early in the process whose solution quality generally dominates the solutions generated by two recently published heuristics. Furthermore, the computation time required is often less than the time taken by the heuristics. Thus, we have an optimizing algorithm that can be used quite effectively as a heuristic when proof of optimality is not an absolute requirement.

A branch-and-price algorithm for integrating urban rail crew scheduling and rostering problems

This paper addresses the problem of routing and wavelength assignment (RWA) in multifiber WDM networks with limited resources. Given a traffic matrix, the number of fibers per link, and the number of wavelengths a fiber can support, we seek to maximize the carried traffic of connections. We formulate the problem as an integer linear program (ILP), and show that the lightpaths selected by this formulation can indeed be established by properly configuring the optical switches. An upper bound on the carried traffic can be computed by solving the linear programming (LP)-relaxation of the ILP formulation. It is shown that this bound can be also computed exactly, and in polynomial-time, by solving a significantly simplified LP which considers only one wavelength. The bound can, thus, easily scale to an arbitrarily large number of wavelengths. Furthermore, we demonstrate that any instance of the RWA problem is also an instance of the more general maximum coverage problem. This allows us to take a greedy algorithm for maximum coverage and obtain an algorithm which provides solutions for the RWA problem that are guaranteed to be within a factor of (1-(1/e)) of the optimal solution. Each iteration of the greedy algorithm selects a set of lightpaths that realizes, using one wavelength, the maximum number of connection requests not previously realized. Computational results confirm the high efficiency of our proposed algorithm.

Floor planning is an important and difficult task in architecture. When planning office buildings, rooms that belong to the same organisational unit should be placed close to each other. This leads to the following NP-hard mathematical optimization problem. Given the outline of each floor, a list of room sizes, and, for each room, the unit to which it belongs, the aim is to compute floor plans such that each room is placed on some floor and the total distance of the rooms within each unit is minimized.The problem can be formulated as an integer linear program (ILP). Commercial ILP solvers exist, but due to the difficulty of the problem, only small to medium instances can be solved to (near-) optimality. For solving larger instances, we propose to split the problem into two subproblems; floor assignment and planning single floors. We formulate both subproblems as ILPs and solve realistic problem instances. Our experimental study shows that splitting the problem helps to reduce the computation time considerably. Where we were able to compute the global optimum, the solution cost of the combined approach increased very little.KeywordsFloor planningProximity requirementsInteger linear programmingNP-hard

A Clique Partitioning Problem (CPP) finds an optimal partition of a given edge-weighted undirected graph, such that the sum of the weights is maximized. This general graph problem has a wide range of real-world applications, including correlation clustering, group technology, community detection, and coalition structure generation. Although a CPP is NP-hard, due to the recent advance of Integer Linear Programming (ILP) solvers, we can solve reasonably large problem instances by formulating a CPP as an ILP instance. The first ILP formulation was introduced by Grötschel and Wakabayashi (Mathematical Programming, 45(1-3), 59–96, 1989). Recently, Miyauchi et al. (2018) proposed a more concise ILP formulation that can significantly reduce transitivity constraints as compared to previously introduced models. In this paper, we introduce a series of concise ILP formulations that can reduce even more transitivity constraints. We theoretically evaluate the amount of reduction based on a simple model in which edge signs (positive/negative) are chosen independently. We show that the reduction can be up to 50% (dependent of the ratio of negative edges) and experimentally evaluate the amount of reduction and the performance of our proposed formulation using a variety of graph data sets. Experimental evaluations show that the reduction can exceed 50% (where edge signs can be correlated), and our formulation outperforms the existing state-of-the-art formulations both in terms of memory usage and computational time for most problem instances.

Integer Linear Programming (ILP) is among the most popular optimization techniques found in practical applications, however, it often faces computational issues in modeling real-world problems. Computation can easily outgrow the computing power of standalone computers as the size of problem increases. The modern distributed computing releases the computing power constraints by providing scalable computing resources to match application needs, which boosts large-scale optimization. This chapter presents a paradigm that leverages Hadoop, an open-source distributed computing framework, to solve a large-scale ILP problem that is abstracted from real-world air traffic flow management. The ILP involves millions of decision variables, which is intractable even with existing state-of-the-art optimization software package. Dual decomposition method is used to separate variables into a set of dual subproblems that are smaller ILPs with lower dimensions, the computation complexity is downsized. As a result, the subproblems are solvable with optimization tools. It is shown that the iterative update on Lagrangian multipliers in dual decomposition method can fit into the Hadoop’s MapReduce programming model, which is designed to allocate computations to cluster for parallel processing and collect results from each node to report aggregate results. Thanks to the scalability of the distributed computing, parallelism can be improved by assigning more working nodes to the Hadoop cluster. As a result, the computational efficiency for solving the whole ILP problem is not impacted by the input size.

Tabu search techniques have been applied to a wide class of optimization problems. Tabu search is a meta procedure that requires a subroutine to find local optima. In most examples of tabu search the subroutine used is problem specific. However, in order to apply tabu search successfully to general 0-1 integer programs, the subroutine must be general. The pivot and complement heuristic is a procedure that frequently finds feasible solutions for general 0-1 integer programs. In this paper we implement several elements of strategies proposed by tabu search method that result in general heuristics for 0-1 integer programs that could be included in an integer programming code. These heuristics employ the ZOOM/XMP implementation of the pivot and complement heuristic as a subroutine. Computational results indicate that these heuristics provide good bounds for many problems. INFORMS Journal on Computing, ISSN 1091-9856, was published as ORSA Journal on Computing from 1989 to 1995 under ISSN 0899-1499.