18 research outputs found
Polynomiality for Bin Packing with a Constant Number of Item Types
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
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
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
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 unless PNP. We consider the case that there
are only a constant number 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 . We present an efficient
polynomial time approximation scheme (EPTAS) for the problem, that is, for any
an assignment with makespan of length at most
times the optimum can be found in polynomial time in the
input length and the exponent is independent of . In particular
we achieve a running time of , where
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
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๋จ๊ณ ๋ฐฐ๋ญ๋ฌธ์ ์ ๋ํ ์ ์๊ณํ๋ชจํ ๋ฐ ์ต์ ํด๋ฒ
ํ์๋
ผ๋ฌธ (์์ฌ) -- ์์ธ๋ํ๊ต ๋ํ์ : ๊ณต๊ณผ๋ํ ์ฐ์
๊ณตํ๊ณผ, 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
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