31 research outputs found

    New bounds for multi-dimensional packing

    Get PDF
    New upper and lower bounds are presented for a multi-dimensional generalization of bin packing called box packing. Several variants of this problem, including bounded space box packing, square packing, variable sized box packing and resource augmented box packing are also studied. The main results, stated for d=2, are as follows: A new upper bound of 2.66013 for online box packing, a new 14/9+varepsilon14/9 + varepsilon polynomial time offline approximation algorithm for square packing, a new upper bound of 2.43828 for online square packing, a new lower bound of 1.62176 for online square packing, a new lower bound of 2.28229 for bounded space online square packing and a new upper bound of 2.32571 for online two-sized box packing

    Online bin packing with resource augmentation

    Get PDF
    In competitive analysis, we usually do not put any restrictions on the computational complexity of online algorithms, although efficient algorithms are preferred. Thus if such an algorithm were given the entire input in advance, it could give an optimal solution (in exponential time). Instead of giving the algorithm more knowledge about the input, in this paper we consider the effects of giving an online bin packing algorithm larger bins than the offline algorithm it is compared to. We give new algorithms for this problem that combine items in bins in an unusual way and give bounds on their performance which improve upon the best possible bounded space algorithm. We also give general lower bounds for this problem which are nearly matching for bin sizes b ?

    Lower bounds for on-line single-machine scheduling

    Get PDF
    The problem of scheduling jobs that arrive over time on a single machine is well-studied. We study the preemptive model and the model with restarts. We provide lower bounds for deterministic and randomized algorithms for several optimality criteria: weighted and unweighted total completion time, and weighted and unweighted total flow time. By using new techniques, we provide the first lower bounds for several of these problems, and we significantly improve the bounds that were known

    This side up!

    Get PDF
    We consider two- and three-dimensional bin packing problems where 9

    Optimal online bounded space multidimensional packing

    Get PDF
    We solve an open problem in the literature by providing an online algorithm for multidimensional bin packing that uses only bounded space. We show that it is optimal among bounded space algorithms for any dimension d>1d>1. Its asymptotic performance ratio is (Piinfty)d(Pi_{infty})^d, where Piinftyapprox1.691Pi_{infty}approx1.691 is the asymptotic performance ratio of the one-dimensional algorithm harm. A modified version of this algorithm for the case where all items are hypercubes is also shown to be optimal. Its asymptotic performance ratio is sublinear in dd. Additionally, for the special case of packing squares in two-dimensional bins, we present a new unbounded space online algorithm with asymptotic performance ratio of at most 2.2712.271. We also present an approximation algorithm for the offline problem with approximation ratio of 16/1116/11. This improves upon all earlier approximation algorithms for this problem, including the algorithm from Caprara, Packing 2-dimensional bins in harmony, Proc. 43rd FOCS, 2002

    New results on flow time with resource augmentation

    Get PDF
    We study the problem of scheduling nn jobs that arrive over time. We consider a non-preemptive setting on a single machine. The goal is to minimize the total flow time. We use extra resource competitive analysis: an optimal off-line algorithm which schedules jobs on a single machine is compared to a more powerful on-line algorithm that has ll machines. We design an algorithm of competitive ratio O(min(Delta^{1/l,n^{1/l)), where DeltaDelta is the maximum ratio between two job sizes, and provide a lower bound which shows that the algorithm is optimal up to a constant factor for any constant ll. The algorithm works for a hard version of the problem where the sizes of the smallest and the largest jobs are not known in advance, only DeltaDelta is known. This gives a trade-off between the resource augmentation and the competitive ratio. We also consider scheduling on parallel identical machines. In this case the optimal off-line algorithm has mm machines and the on-line algorithm has lmlm machines. We give a lower bound for this case. Next, we give lower bounds for algorithms using resource augmentation on the speed. Finally, we consider scheduling with hard deadlines

    Minimizing the maximum starting time on-line

    Get PDF
    We study the scheduling problem of minimizing the maximum starting time on-line. The goal is to minimize the last time that a job starts. We show that while the greedy algorithm has a competitive ratio of Theta(logm)Theta(log m), we can give a constant competitive algorithm for this problem. We also show that the greedy algorithm is optimal for resource augmentation in the sense that it requires 2m-1 machines to have a competitive ratio of 1, whereas no algorithm can achieve this with 2m-1 machines

    Bounds for online bounded space hypercube packing

    Get PDF
    In hypercube packing, we receive a sequence of hypercubes that need to be packed into unit hypercubes which are called bins. Items arrive online and each item must be placed within its bin without overlapping with other items in that bin. The goal is to minimize the total number of bins used. We present lower and upper bounds for online bounded space hypercube packing in dimensions 2,...,

    Minimizing the total completion time on-line on a single machine, using restarts

    Get PDF
    We give an algorithm to minimize the total completion time on-line on a single machine, using restarts, with a competitive ratio of 3/2. The optimal competitive ratio without using restarts is 2 for deterministic algorithms and e/(e−1)approx1.582e/(e-1) approx 1.582 for randomized algorithms. This is the first restarting algorithm to minimize the total completion time that is proved to be better than an algorithm that does not restart
    corecore