No full-text available
To read the full-text of this research,
you can request a copy directly from the authors.
Automation of the System of Efficient Packaging of Cargoes by Containers Using Heuristic Algorithms
ResearchGate has not been able to resolve any citations for this publication.
The three-dimensional bin packing problem (3D-BPP) is to select one or more bins from a set of available bins to pack three dimensional, rectangular boxes such that the usage of the bin space is maximized. 3D-BPP finds wide applications in pharmaceutical industry, transportation and packaging system. In the traditional 3D-BPP, the holding bins are of identical size, while the problem considered in this paper addresses the case where bins are heterogeneous, i.e., varying in size. We present a genetic algorithm along with a novel heuristic packing procedure. The packing heuristic procedure converts box packing sequence and container loading sequence encoded in a chromosome into a compact packing solution. The genetic algorithm is used to evolve such sequences. The algorithm is first applied to 12 industrial instances and then tested on randomly generated instances. The results demonstrate that solutions with high quality can be found within reasonable time.
The cutting-stock problem is the problem of filling an order at minimum cost for specified numbers of lengths of material to be cut from given stock lengths of given cost. When expressed as an integer programming problem the large number of variables involved generally makes computation infeasible. This same difficulty persists when only an approximate solution is being sought by linear programming. In this paper, a technique is described for overcoming the difficulty in the linear programming formulation of the problem. The technique enables one to compute always with a matrix which has no more columns than it has rows.
In earlier papers on the cutting stock problem we indicated the desirability of developing fast methods for computing knapsack functions. A one-dimensional knapsack function is defined by: f(x)= \max \{\Pi_{1} Z_{1} + \cdots + \Pi_{m}Z_{m};\enspace l_{1}Z_{1} + \cdots + l_{M}Z_{m}\leq x,\; Z_{i}\geq 0,\; Z_{i}\ \mbox{integer}\} where Πi and li are given constants, i = 1, …, m. Two-dimensional knapsack functions can also be defined. In this paper we give a characterization of knapsack functions and then use the characterization to develop more efficient methods of computation. For one-dimensional knapsack functions we describe certain periodic properties and give computational results.
The problem addressed in this paper is that of orthogonally packing a given set of rectangular-shaped items into a minimum number of three-dimensional rectangular bins. We harness the computing power of the modern day computers to solve this NP-Hard problem that would be otherwise practically extremely difficult. The software tool that we develop using both heuristics and some knapsack problem approach, presents the solutions as a 3D graphical representation of the solution space. The visual and interactive ability of the simulation model provides a disciplined approach to solving the 3D Bin Packing Problem.
Inspired by virtual machine placement problems, we study heuristics for the Vector Bin Packing problem, where we are required to pack n items represented by d-dimensional vectors, into as few bins of size 1 d each as possible. We systematically study variants of the First Fit Decreasing (FFD) algorithm that have been proposed for this problem. Inspired by bad instances for FFD-type algorithms, we propose new ge-ometric heuristics that run nearly as fast as FFD for reasonable values of n and d. We report on empirical evaluations of the FFD-based, as well as the new heuristics on large families of distributions. We identify which FFD variants work best in most cases and show that our new heuristics usually outperform FFD-based heuristics and can sometimes reduce the number of bins used by up to ten percent. Further, in all cases where we were able to compute the optimal solution we found our new heuristics within few percent of optimal. We conclude that these new heuristics are an excellent alternative to FFD-based heuristics and are prime candidates to be used in practice.
Cutting and packing problems appear under various names in literature, e.g. cutting stock or trim loss problem, bin or strip packing problem, vehicle, pallet or container loading problem, nesting problem, knapsack problem etc. The paper develops a consistent and systematic approach for a comprehensive typology integrating the various kinds of problems. The typology is founded on the basic logical structure of cutting and packing problems. The purpose is to unify the different use of notions in the literature and to concentrate further research on special types of problems.
The bin packing problem consists of finding the minimum number of bins, of given capacity D, required to pack a set of objects, each having a certain weight. We consider the high-multiplicity version of the problem, in which there are only C different weight values. We show that when C=2 the problem can be solved in time O( log D). For the general case, we give an algorithm which provides a solution requiring at most C−2 bins more than the optimal solution, i.e., an algorithm that is asymptotically exact. For fixed C, the complexity of the algorithm is O(poly( log D)), where poly(·) is a polynomial function not depending on C.
A survey of some theoretical concepts in discrete optimization is given.
Given n items, each having, say, a weight and a length, and n identical bins with a weight and a length capacity, the 2-Dimensional Vector Packing Problem (2-DVPP) calls for packing all the items into the minimum number of bins. The problem is NP-hard, and has applications in loading, scheduling and layout design. As for the closely related Bin Packing Problem (BPP), there are two main possible approaches for the practical solution of 2-DVPP. The first approach is based on lower bounds and heuristics based on combinatorial considerations, which are fast but in some cases not effective enough to provide optimal solutions when embedded within a branch-and-bound scheme. The second approach is based on an integer programming formulation with a huge number of variables, whose linear programming relaxation can be solved by column generation, typically requiring a considerable time, but obtaining extensive information about the optimal solution of the problem. In this paper we first analyze several lower bounds for 2-DVPP. In particular, we determine an upper bound on the worst-case performance of a class of lower bounding procedures derived from BPP. We also prove that the lower bound associated with the huge linear programming relaxation dominates all the other lower bounds we consider. We then introduce heuristic and exact algorithms, and report extensive computational results on several instance classes, showing that in some cases the combinatorial approach allows for a fast solution of the problem, while in other cases one has to resort to the huge formulation for finding optimal solutions. Our results compare favorably with previous approaches to the problem.
The two-dimensional vector packing (2DVP) problem can be stated as follows. Given are N objects, each of which has two requirements. The problem is to find the minimum number of bins needed to pack all objects, where the capacity of each bin equals 1 in both requirements. A heuristic adapted from the first fit decreasing rule is proposed, and lower bounds for optimal solutions to the 2DVP problem are investigated. Computing one of these lower bounds is shown to be equivalent to computing the largest number of vertices of a clique of a 2-threshold graph (which can be done in polynomial time). These lower bounds are incorporated into a branch-and-bound algorithm, for which some limited computational experiments are reported.
Exact and approximate algorithms are presented for scheduling independent tasks in a multiprocessor environment in which the processors have different speeds. Dynamic programming type algorithms are presented which minimize finish time and weighted mean flow time on two processors. The generalization to m processors is direct. These algorithms have a worst-case complexity which is exponential in the number of tasks. Therefore approximation algorithms of low polynomial complexity are also obtained for the above problems. These algorithms are guaranteed to obtain solutions that are close to the optimal. For the case of minimizing mean flow time on m-processors an algorithm is given whose complexity is O(n log mn).
The FIRST FIT DECREASING algorithm for bin packing has long been famous for its guarantee that no packing it generates will use more than times the optimal number of bins. We present a simple modified version that has essentially the same running time, should perform at least as well on average, and yet provides a guarantee of .
Aggregation of information and estimation of cargo route parameters based on machine learning methods in conditions of information scarcity
- Abramov
Methods of rational metal cutting
- Kantorovich
Raschet racional’nogo raskroja promyshlennyh materialov [Calculation of rational cutting of industrial materials]
- Kantorovich
Rational cutting of industrial materials
- Kantorovich
Razvitie metodov reshenija zadach plotnoj upakovki obektov proizvol’noj formy i razlichnoj razmernosti
- Chekanin
The Tight Bound of First Fit Decreasing Bin-Packing Algorithm Is FFD(I) ≤ 11/9 OPT(I) + 6/9. Combinatorics, Algorithms, Probabilistic and Experimental Methodologies
- Dósa