Problems involving the efficient arrangement of simple objects, as captured by bin packing and makespan scheduling, are fundamental tasks in combinatorial optimization. These are well understood in the traditional online and offline cases, but have been less well-studied when the volume of the input is truly massive, and cannot even be read into memory. This is captured by the streaming model of computation, where the aim is to approximate the cost of the solution in one pass over the data, using small space. As a result, streaming algorithms produce concise input summaries that approximately preserve the optimum value. We design the first efficient streaming algorithms for these fundamental problems in combinatorial optimization. For Bin Packing, we provide a streaming asymptotic @math -approximation with @math memory, where @math hides logarithmic factors. Moreover, such a space bound is essentially optimal. Our algorithm implies a streaming @math -approximation for Vector Bin Packing in @math dimensions, running in space @math . For the related Vector Scheduling problem, we show how to construct an input summary in space @math that preserves the optimum value up to a factor of @math , where @math is the number of identical machines.
Makespan scheduling on identical machines is one of the most basic and fundamental packing problems studied in the discrete optimization literature. It asks for an assignment of @math jobs to a set of @math identical machines that minimizes the makespan. The problem is strongly NP-hard, and thus we do not expect a @math -approximation algorithm with a running time that depends polynomially on @math . Furthermore, [3] recently showed that a running time of @math for any @math would imply that the Exponential Time Hypothesis (ETH) fails. A long sequence of algorithms have been developed that try to obtain low dependencies on @math , the better of which achieves a running time of @math [11]. In this paper we obtain an algorithm with a running time of @math , 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 @math . We consider the classical scheduling problem on parallel identical machines to minimize the makespan. There is a long history of studies on this problem, focusing on exact and approximation algorithms, and it is thus natural to consider whether these algorithms are best possible in terms of the running time. Under the Exponential Time Hypothesis (ETH), we achieve the following results in this paper: • The scheduling problem on a constant number m of identical machines, which is denoted as Pm||Cmax, is known to admit a fully polynomial time approximation scheme (FPTAS) of running time O(n) + (1 e)O(m) (indeed, the algorithm works for an even more general problem where machines are unrelated). We prove this algorithm is essentially the best possible in the sense that a (1 e)O(m1-δ) + nO(1) time FPTAS for any δ > 0 implies that ETH fails. • The scheduling problem on an arbitrary number of identical machines, which is denoted as P||Cmax, is known to admit a polynomial time approximation scheme (PTAS) of running time 2O(1 e2 log3(1 e))+nO(1). We prove this algorithm is nearly optimal in the sense that a 2O((1 e)1-δ+nO(1) time PTAS for any δ > 0 implies that ETH fails, leaving a small room for improvement. In addition, we also consider exact algorithms for the scheduling problem and prove the following result: • The traditional dynamic programming algorithm for P||Cmax is known to run in 2O(n) time. We prove this is essentially the best possible in the sense that even if we restrict that there are n jobs and the processing time of each job is bounded by O(n), an exact algorithm of running time 22O(n1-δ) for any δ > 0 implies that ETH fails. To obtain these results we will provide two new reductions from 3SAT, one for Pm||Cmax and another for P||Cmax. Indeed, the new reductions explore the structure of scheduling problems and can also lead to other interesting results. For example, using the framework of our reduction for P||Cmax, [5] are able to prove the APX-hardness of the scheduling problem in which the matrix of job processing times P = (pij)mxn is of rank 3, solving the open problem mentioned in [2]. 