Smart greedy procedure for solving a nOnlinear knapsack class of reliability optimization problems

A new heuristic procedure, which is called Smart Greedy, is proposed for solving a kind of general reliability optimization problems (non-DGR type knapsack problems). Smart Greedy uses Recursive Greedy with multiple greedy functions designated by balance coefficients, generates several solutions and then determines the best solution among them as the smart greedy solution. Recursive Greedy first checks the feasibility of sets of items for a given problem and removes infeasible items from the item sets. Second, the procedure checks the gain ratio of increments of objective function to constraint function and reduces the problem to DGR type problem by invoking LP dominance. Third, the procedure continues to allocate the increments for current items until the constraint is violated. With the current solution, the procedure then repeats the greedy procedure for current items that are added to the items removed by the LP dominance in the previous step.Computational results show that the Smart Greedy is more effective than the previously reported methods.     

On the optimality of the greedy solutions of the general knapsack problems

Summary: In this paper we submit a unified discussion of some closely related results which were achieved independently in number theory and integer programming, and we partially generalize them. In the unified discussion we treat together two problems where the greedy method has different characters, in the first one it is an internal-point algorithm, in the second one it is an outer-point method. We call a knapsack problem "pleasant" if the greedy solution is optimal for every right-hand side. A sufficient and two finite necessary and sufficient conditions for the pleasantness of a problem are discussed. The sufficient condition can be checked very easily. The paper is finished with an error analysis of some nonpleasant problems     

Advanced greedy algorithms and surrogate constraint methods for linear and quadratic knapsack and covering problems

New variants of greedy algorithms, called advanced greedy algorithms, are identified for knapsack and covering problems with linear and quadratic objective functions. Beginning with single-constraint problems, we provide extensions for multiple knapsack and covering problems, in which objects must be allocated to different knapsacks and covers, and also for multi-constraint (multi-dimensional) knapsack and covering problems, in which the constraints are exploited by means of surrogate constraint strategies. In addition, we provide a new graduated-probe strategy for improving the selection of variables to be assigned values. Going beyond the greedy and advanced greedy frameworks, we describe ways to utilize these algorithms with multi-start and strategic oscillation metaheuristics. Finally, we identify how surrogate constraints can be utilized to produce inequalities that dominate those previously proposed and tested utilizing linear programming methods for solving multi-constraint knapsack problems, which are responsible for the current best methods for these problems. While we focus on 0–1 problems, our approaches can readily be adapted to handle variables with general upper bounds.     

On parallelizing a greedy heuristic for finding small dominant sets

We analyse a greedy heuristic for finding small dominating sets in graphs: bounds on the size of the dominating set so produced had previously been derived in terms of the size of a smallest dominating set and the number of vertices and edges in the graph, respectively, We show that computing the resulting small dominating set isP-hard and so cannot be done efficiently in parallel (in the context of the PRAM model of parallel computation). We also consider a related non-deterministic greedy heuristic.     

Another greedy heuristic for the constrained forest problem

The constrained forest problem seeks a minimum-weight spanning forest in an undirected edge-weighted graph such that each tree spans at least a specified number of vertices. We present a greedy heuristic for this NP-hard problem, whose solutions are at least as good as, and often better than, those produced by the best-known 2-approximate heuristic.     

A fuzzy greedy heuristic for permutation flow-shop scheduling

This paper describes a polynomial-time heuristic for the permutation flow-shop scheduling problem with the makespan criterion. The proposed method consists of two phases: arranging the jobs in priority order and then constructing a sequence. A fuzzy greedy evaluation function is employed to prioritize the jobs for incorporating into the construction phase of the heuristic. Computational experiments using standard benchmark problems indicate an improvement of the new heuristic over the well-known Nawaz, Enscore and Ham (NEH) heuristic. It will be seen that the NEH heuristic is a special case of our more general heuristic.     

An effective greedy heuristic for the Social Golfer Problem

The Social Golfer Problem (SGP) is a combinatorial optimization problem that exhibits a lot of symmetry and has recently attracted significant attention. In this paper, we present a new greedy heuristic for the SGP, based on the intuitive concept of freedom among players. We use this heuristic in a complete backtracking search, and match the best current results of constraint solvers for several SGP instances with a much simpler method. We then use the main idea of the heuristic to construct initial configurations for a metaheuristic approach, and show that this significantly improves results obtained by local search alone. In particular, our method is the first metaheuristic technique that can solve the original problem instance optimally. We show that our approach is also highly competitive with other metaheuristic and constraint-based methods on many other benchmark instances from the literature.     

A heuristic algorithm for the multidimensional zero-one knapsack problem

Computational and theoretical aspects of a new heuristic for the multidimensional zero-one knapsack problem are studied. Its computational efficiency is compared with two other well-known heuristics.     

A greedy heuristic for the capacitated minimum spanning tree problem

This paper develops a greedy heuristic for the capacitated minimum spanning tree problem (CMSTP), based on the two widely known methods of Prim and of Esau–Williams. The proposed algorithm intertwines two-stages: an enhanced combination of the Prim and Esau–Williams approaches via augmented and synthetic node selection criteria, and an increase of the feasible solution space by perturbing the input data using the law of cosines. Computational tests on benchmark problems show that the new heuristic provides extremely good performance results for the CMSTP, justifying its effectiveness and robustness. Furthermore, excluding the feasible space expansion, we show that we can still obtain good quality solutions in very short computational times.     

Fractional knapsack problems

The fractional knapsack problem to obtain an integer solution that maximizes a linear fractional objective function under the constraint of one linear inequality is considered. A modification of the Dinkelbach's algorithm [3] is proposed to exploit the fact that good feasible solutions are easily obtained for both the fractional knapsack problem and the ordinary knapsack problem. An upper bound of the number of iterations is derived. In particular it is clarified how optimal solutions depend on the right hand side of the constraint; a fractional knapsack problem reduces to an ordinary knapsack problem if the right hand side exceeds a certain bound.     

Sensitivity analysis for abstract equilibrium problems

We develop the general framework of sensitivity analysis for equilibrium problems in the setting of vector topological normed space. Our approach does not make any recourse to geometrical properties and the obtained result can be viewed as an extension and generalization of the well-known results (on variational inequalities) in the literature. Even though we have worked under arbitrary constraints Kλ with Hölder-property—that have been decisive in our treatment—we have obtained, in a similar spirit of Domokos [J. Math. Anal. Appl. 230 (1999) 382-389], the best lower bound for the continuity modulus despite of the properties of the boundary of Kλ.     

Sensitivity analysis for generalized linear-quadratic problems

In this paper, we study simple necessary and sufficient conditions for the stability of generalized linear-quadratic programs under perturbations of the data. The concept of generalized linear-quadratic problem was introduced by Rockafellar and Wets and consists of solving saddle points of a linear-quadratic convex concave functionJ onU×V, whereU andV are polyhedral convex sets in ⁿ and ^m . This paper also establishes results on the closedness and the uniform boundedness of the saddle-point solution sets. These properties are then used to obtain results on the continuity and the directional derivative of the perturbed saddle value.The research of the first author was supported by the CEE, Grant No. CI1-CT92-0046.     

Hybrid rounding techniques for knapsack problems

We address the classical knapsack problem and a variant in which an upper bound is imposed on the number of items that can be selected. We show that appropriate combinations of rounding techniques yield novel and more powerful ways of rounding. Moreover, we present a linear-storage polynomial time approximation scheme (PTAS) and a fully polynomial time approximation scheme (FPTAS) that compute an approximate solution, of any fixed accuracy, in linear time. These linear complexity bounds give a substantial improvement of the best previously known polynomial bounds [A. Caprara, et al., Approximation algorithms for knapsack problems with cardinality constraints, European J. Oper. Res. 123 (2000) 333-345].     

A note on a greedy heuristic for flow-shop makespan minimization with no machine idle-time

We study makespan minimization on an m machine flowshop. No idle time is allowed between consecutive operations on each machine. We introduce an efficient (O(n²)) greedy algorithm, which is shown numerically to perform better than a recently published heuristic.     

Buffer allocation for a class of nonlinear stochastic knapsack problems

In this paper, we examine a class of nonlinear, stochastic knapsack problems which occur in manufacturing, facility or other network design applications.Series, merge-and-split topologies of series-parallelM/M/1/K andM/M/C/K queueing networks with an overall buffer constraint bound are examined. Bounds on the objective function are proposed and a sensitivity analysis is utilized to quantify the effects of buffer variations on network performance measures.     

Average behavior of greedy algorithms for the minimization knapsack problem: General coefficient distributions

For the minimization knapsack problem with Boolean variables, primal and dual greedy algorithms are formally described. Their relations to the corresponding algorithms for the maximization knapsack problem are shown. The average behavior of primal and dual algorithms for the minimization problem is analyzed. It is assumed that the coefficients of the objective function and the constraint are independent identically distributed random variables on [0, 1] with an arbitrary distribution having a density and that the right-hand side d is deterministic and proportional to the number of variables (i.e., d = μn). A condition on μ is found under which the primal and dual greedy algorithms have an asymptotic error of t.     

Quadratic bottleneck knapsack problems

In this paper we study the quadratic bottleneck knapsack problem (QBKP) from an algorithmic point of view. QBKP is shown to be NP-hard and it does not admit polynomial time ?-approximation algorithms for any ?>0 (unless P=NP). We then provide exact and heuristic algorithms to solve the problem and also identify polynomially solvable special cases. Results of extensive computational experiments are reported which show that our algorithms can solve QBKP of reasonably large size and produce good quality solutions very quickly. Several variations of QBKP are also discussed.