18 research outputs found

    Polynomiality for Bin Packing with a Constant Number of Item Types

    Full text link
    We consider the bin packing problem with d different item sizes s_i and item multiplicities a_i, where all numbers are given in binary encoding. This problem formulation is also known as the 1-dimensional cutting stock problem. In this work, we provide an algorithm which, for constant d, solves bin packing in polynomial time. This was an open problem for all d >= 3. In fact, for constant d our algorithm solves the following problem in polynomial time: given two d-dimensional polytopes P and Q, find the smallest number of integer points in P whose sum lies in Q. Our approach also applies to high multiplicity scheduling problems in which the number of copies of each job type is given in binary encoding and each type comes with certain parameters such as release dates, processing times and deadlines. We show that a variety of high multiplicity scheduling problems can be solved in polynomial time if the number of job types is constant

    Closing the Gap for Makespan Scheduling via Sparsification Techniques

    Get PDF
    Makespan scheduling on identical machines is one of the most basic and fundamental packing problem studied in the discrete optimization literature. It asks for an assignment of n jobs to a set of m identical machines that minimizes the makespan. The problem is strongly NPhard, and thus we do not expect a (1 + epsilon)-approximation algorithm with a running time that depends polynomially on 1/epsilon. Furthermore, Chen et al. [Chen/JansenZhang, SODA\u2713] recently showed that a running time of 2^{1/epsilon}^{1-delta} + poly(n) for any delta > 0 would imply that the Exponential Time Hypothesis (ETH) fails. A long sequence of algorithms have been developed that try to obtain low dependencies on 1/epsilon, the better of which achieves a running time of 2^{~O(1/epsilon^{2})} + O(n*log(n)) [Jansen, SIAM J. Disc. Math. 2010]. In this paper we obtain an algorithm with a running time of 2^{~O(1/epsilon)} + O(n*log(n)), which is tight under ETH up to logarithmic factors on the exponent. Our main technical contribution is a new structural result on the configuration-IP. More precisely, we show the existence of a highly symmetric and sparse optimal solution, in which all but a constant number of machines are assigned a configuration with small support. This structure can then be exploited by integer programming techniques and enumeration. We believe that our structural result is of independent interest and should find applications to other settings. In particular, we show how the structure can be applied to the minimum makespan problem on related machines and to a larger class of objective functions on parallel machines. For all these cases we obtain an efficient PTAS with running time 2^{~O(1/epsilon)} + poly(n)

    Scheduling Kernels via Configuration LP

    Get PDF
    Makespan minimization (on parallel identical or unrelated machines) is arguably the most natural and studied scheduling problem. A common approach in practical algorithm design is to reduce the size of a given instance by a fast preprocessing step while being able to recover key information even after this reduction. This notion is formally studied as kernelization (or simply, kernel) - a polynomial time procedure which yields an equivalent instance whose size is bounded in terms of some given parameter. It follows from known results that makespan minimization parameterized by the longest job processing time p_max has a kernelization yielding a reduced instance whose size is exponential in p_max. Can this be reduced to polynomial in p_max? We answer this affirmatively not only for makespan minimization, but also for the (more complicated) objective of minimizing the weighted sum of completion times, also in the setting of unrelated machines when the number of machine kinds is a parameter. Our algorithm first solves the Configuration LP and based on its solution constructs a solution of an intermediate problem, called huge N-fold integer programming. This solution is further reduced in size by a series of steps, until its encoding length is polynomial in the parameters. Then, we show that huge N-fold IP is in NP, which implies that there is a polynomial reduction back to our scheduling problem, yielding a kernel. Our technique is highly novel in the context of kernelization, and our structural theorem about the Configuration LP is of independent interest. Moreover, we show a polynomial kernel for huge N-fold IP conditional on whether the so-called separation subproblem can be solved in polynomial time. Considering that integer programming does not admit polynomial kernels except for quite restricted cases, our "conditional kernel" provides new insight

    An EPTAS for Scheduling on Unrelated Machines of Few Different Types

    Full text link
    In the classical problem of scheduling on unrelated parallel machines, a set of jobs has to be assigned to a set of machines. The jobs have a processing time depending on the machine and the goal is to minimize the makespan, that is the maximum machine load. It is well known that this problem is NP-hard and does not allow polynomial time approximation algorithms with approximation guarantees smaller than 1.51.5 unless P==NP. We consider the case that there are only a constant number KK of machine types. Two machines have the same type if all jobs have the same processing time for them. This variant of the problem is strongly NP-hard already for K=1K=1. We present an efficient polynomial time approximation scheme (EPTAS) for the problem, that is, for any ฮต>0\varepsilon > 0 an assignment with makespan of length at most (1+ฮต)(1+\varepsilon) times the optimum can be found in polynomial time in the input length and the exponent is independent of 1/ฮต1/\varepsilon. In particular we achieve a running time of 2O(Klogโก(K)1ฮตlogโก41ฮต)+poly(โˆฃIโˆฃ)2^{\mathcal{O}(K\log(K) \frac{1}{\varepsilon}\log^4 \frac{1}{\varepsilon})}+\mathrm{poly}(|I|), where โˆฃIโˆฃ|I| denotes the input length. Furthermore, we study three other problem variants and present an EPTAS for each of them: The Santa Claus problem, where the minimum machine load has to be maximized; the case of scheduling on unrelated parallel machines with a constant number of uniform types, where machines of the same type behave like uniformly related machines; and the multidimensional vector scheduling variant of the problem where both the dimension and the number of machine types are constant. For the Santa Claus problem we achieve the same running time. The results are achieved, using mixed integer linear programming and rounding techniques

    Additive Approximation Schemes for Load Balancing Problems

    Get PDF
    We formalize the concept of additive approximation schemes and apply it to load balancing problems on identical machines. Additive approximation schemes compute a solution with an absolute error in the objective of at most ? h for some suitable parameter h and any given ? > 0. We consider the problem of assigning jobs to identical machines with respect to common load balancing objectives like makespan minimization, the Santa Claus problem (on identical machines), and the envy-minimizing Santa Claus problem. For these settings we present additive approximation schemes for h = p_{max}, the maximum processing time of the jobs. Our technical contribution is two-fold. First, we introduce a new relaxation based on integrally assigning slots to machines and fractionally assigning jobs to the slots. We refer to this relaxation as the slot-MILP. While it has a linear number of integral variables, we identify structural properties of (near-)optimal solutions, which allow us to compute those in polynomial time. The second technical contribution is a local-search algorithm which rounds any given solution to the slot-MILP, introducing an additive error on the machine loads of at most ?? p_{max}

    2์ฐจ์› 2๋‹จ๊ณ„ ๋ฐฐ๋‚ญ๋ฌธ์ œ์— ๋Œ€ํ•œ ์ •์ˆ˜๊ณ„ํš๋ชจํ˜• ๋ฐ ์ตœ์ ํ•ด๋ฒ•

    Get PDF
    ํ•™์œ„๋…ผ๋ฌธ (์„์‚ฌ) -- ์„œ์šธ๋Œ€ํ•™๊ต ๋Œ€ํ•™์› : ๊ณต๊ณผ๋Œ€ํ•™ ์‚ฐ์—…๊ณตํ•™๊ณผ, 2021. 2. ์ด๊ฒฝ์‹.In this thesis, we study integer programming models and exact algorithms for the two-dimensional two-staged knapsack problems, which maximizes the profit by cutting a single rectangular plate into smaller rectangular items by two-staged guillotine cuts. We first introduce various integer programming models, including the strip-packing model, the staged-pattern model, the level-packing model, and the arc-flow model for the problem. Then, a hierarchy of the strength of the upper bounds provided by the LP-relaxations of the models is established based on theoretical analysis. We also show that there exists a polynomial-size model that has not been proven yet as far as we know. Exact methods, including branch-and-price algorithms using the strip-packing model and the staged-pattern model, are also devised. Computational experiments on benchmark instances are conducted to examine the strength of upper bounds obtained by the LP-relaxations of the models and evaluate the performance of exact methods. The results show that the staged-pattern model gives a competitive theoretical and computational performance.๋ณธ ๋…ผ๋ฌธ์€ 2๋‹จ๊ณ„ ๊ธธ๋กœํ‹ด ์ ˆ๋‹จ(two-staged guillotine cut)์„ ์‚ฌ์šฉํ•˜์—ฌ ์ด์œค์„ ์ตœ๋Œ€ํ™”ํ•˜๋Š” 2์ฐจ์› 2๋‹จ๊ณ„ ๋ฐฐ๋‚ญ ๋ฌธ์ œ(two-dimensional two-staged knapsack problem: ์ดํ•˜ 2TDK)์— ๋Œ€ํ•œ ์ •์ˆ˜์ตœ์ ํ™” ๋ชจํ˜•๊ณผ ์ตœ์ ํ•ด๋ฒ•์„ ๋‹ค๋ฃฌ๋‹ค. ์šฐ์„ , ๋ณธ ์—ฐ๊ตฌ์—์„œ๋Š” ์ŠคํŠธ๋ฆฝํŒจํ‚น๋ชจํ˜•, ๋‹จ๊ณ„ํŒจํ„ด๋ชจํ˜•, ๋ ˆ๋ฒจํŒจํ‚น๋ชจํ˜•, ๊ทธ๋ฆฌ๊ณ  ํ˜ธ-ํ๋ฆ„๋ชจํ˜•๊ณผ ๊ฐ™์€ ์ •์ˆ˜์ตœ์ ํ™” ๋ชจํ˜•๋“ค์„ ์†Œ๊ฐœํ•œ๋‹ค. ๊ทธ ๋’ค, ๊ฐ๊ฐ์˜ ๋ชจํ˜•์˜ ์„ ํ˜•๊ณ„ํš์™„ํ™”๋ฌธ์ œ์— ๋Œ€ํ•ด ์ƒํ•œ๊ฐ•๋„๋ฅผ ์ด๋ก ์ ์œผ๋กœ ๋ถ„์„ํ•˜์—ฌ ์ƒํ•œ๊ฐ•๋„ ๊ด€์ ์—์„œ ๋ชจํ˜•๋“ค ๊ฐ„ ์œ„๊ณ„๋ฅผ ์ •๋ฆฝํ•œ๋‹ค. ๋˜ํ•œ, ๋ณธ ์—ฐ๊ตฌ์—์„œ๋Š” 2TDK์˜ ๋‹คํ•ญํฌ๊ธฐ(polynomial-size) ๋ชจํ˜•์˜ ์กด์žฌ์„ฑ์„ ์ฒ˜์Œ์œผ๋กœ ์ฆ๋ช…ํ•œ๋‹ค. ๋‹ค์Œ์œผ๋กœ ๋ณธ ์—ฐ๊ตฌ๋Š” 2TDK์˜ ์ตœ์ ํ•ด๋ฅผ ๊ตฌํ•˜๋Š” ์•Œ๊ณ ๋ฆฌ์ฆ˜์œผ๋กœ์จ ํŒจํ„ด๊ธฐ๋ฐ˜๋ชจํ˜•๋“ค์— ๋Œ€ํ•œ ๋ถ„์ง€ํ‰๊ฐ€ ์•Œ๊ณ ๋ฆฌ์ฆ˜๊ณผ ๋ ˆ๋ฒจํŒจํ‚น๋ชจํ˜•์„ ๊ธฐ๋ฐ˜์œผ๋กœ ํ•œ ๋ถ„์ง€์ ˆ๋‹จ ์•Œ๊ณ ๋ฆฌ์ฆ˜์„ ์ œ์•ˆํ•œ๋‹ค. ๋‹จ๊ณ„ํŒจํ„ด๋ชจํ˜•์ด ์ด๋ก ์ ์œผ๋กœ๋„ ๊ฐ€์žฅ ์ข‹์€ ์ƒํ•œ๊ฐ•๋„๋ฅผ ๋ณด์žฅํ•  ๋ฟ๋งŒ ์•„๋‹ˆ๋ผ, ๊ณ„์‚ฐ ๋ถ„์„์„ ํ†ตํ•ด ๋‹จ๊ณ„ํŒจํ„ด๋ชจํ˜•์„ ๊ธฐ๋ฐ˜์œผ๋กœ ํ•œ ๋ถ„์ง€ํ‰๊ฐ€ ์•Œ๊ณ ๋ฆฌ์ฆ˜์ด ์ œํ•œ๋œ ์‹œ๊ฐ„ ๋‚ด ์ข‹์€ ํ’ˆ์งˆ์˜ ๊ฐ€๋Šฅํ•ด๋ฅผ ์ฐพ์Œ์„ ํ™•์ธํ•˜์˜€๋‹ค.Abstract i Contents iv List of Tables vi List of Figures vii Chapter 1 Introduction 1 1.1 Problem Description . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 1.2 Literature Review . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 1.3 Contributions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 1.4 Organization of the Thesis . . . . . . . . . . . . . . . . . . . . . . . . 8 Chapter 2 Integer Programming Models for 2TDK 9 2.1 Pattern-based Model . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 2.2 Arc-flow Model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 2.3 Level Packing Model . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 Chapter 3 Theoretical Analysis of Integer Programming Models 20 3.1 Upper Bounds of AF and SM(1;1) . . . . . . . . . . . . . . . . . . 20 3.2 Upper Bounds of ML, PM(d), and SM(d; d) . . . . . . . . . . . . . . 21 3.3 Polynomial-size Model . . . . . . . . . . . . . . . . . . . . . . . . . . 29 Chapter 4 Exact Methods 33 4.1 Branch-and-price Algorithm for the Strip Packing Model . . . . . . . 34 4.2 Branch-and-price Algorithm for the Staged-pattern Model . . . . . . 39 4.2.1 The Standard Scheme . . . . . . . . . . . . . . . . . . . . . . 39 4.2.2 The Height-aggregated Scheme . . . . . . . . . . . . . . . . . 40 4.3 Branch-and-cut Algorithm for the Modified Level Packing Model . . 44 Chapter 5 Computational Experiments 46 5.1 Instances . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46 5.2 Upper Bounds Comparison . . . . . . . . . . . . . . . . . . . . . . . 49 5.2.1 A Group of Small Instances . . . . . . . . . . . . . . . . . . . 49 5.2.2 A Group of Large Instances . . . . . . . . . . . . . . . . . . . 55 5.2.3 Class 5 Instances . . . . . . . . . . . . . . . . . . . . . . . . . 61 5.3 Solving Instances to Optimality . . . . . . . . . . . . . . . . . . . . . 65 5.3.1 A Group of Small Instances . . . . . . . . . . . . . . . . . . . 65 5.3.2 A Group of Large Instances . . . . . . . . . . . . . . . . . . . 69 5.3.3 Class 5 Instances . . . . . . . . . . . . . . . . . . . . . . . . . 72 Chapter 6 Conclusion 77 Bibliography 79 ๊ตญ๋ฌธ์ดˆ๋ก 83Maste

    Approximating Vector Scheduling: Almost Matching Upper and Lower Bounds

    Get PDF
    Abstract We consider the Vector Scheduling problem, a natural generalization of the classical makespan minimization problem to multiple resources. Here, we are given n jobs, represented as d-dimensional vectors in [0, 1] d , and m identical machines, and the goal is to assign the jobs to machines such that the maximum load of each machine over all the coordinates is at most 1. For fixed d, the problem admits an approximation scheme, and the best known running time is n f ( ,d) where In particular, the dependence on d is double exponential. In this paper we show that a double exponential dependence on d is necessary, and give an improved algorithm with essentially optimal running time. Specifically, we let exp(x) denote 2 x and show that: (1) For any < 1, there is no This gives the first efficient approximation scheme (EPTAS) for the problem
    corecore