53 research outputs found

    How Unsplittable-Flow-Covering helps Scheduling with Job-Dependent Cost Functions

    Full text link
    Generalizing many well-known and natural scheduling problems, scheduling with job-specific cost functions has gained a lot of attention recently. In this setting, each job incurs a cost depending on its completion time, given by a private cost function, and one seeks to schedule the jobs to minimize the total sum of these costs. The framework captures many important scheduling objectives such as weighted flow time or weighted tardiness. Still, the general case as well as the mentioned special cases are far from being very well understood yet, even for only one machine. Aiming for better general understanding of this problem, in this paper we focus on the case of uniform job release dates on one machine for which the state of the art is a 4-approximation algorithm. This is true even for a special case that is equivalent to the covering version of the well-studied and prominent unsplittable flow on a path problem, which is interesting in its own right. For that covering problem, we present a quasi-polynomial time (1+ϵ)(1+\epsilon)-approximation algorithm that yields an (e+ϵ)(e+\epsilon)-approximation for the above scheduling problem. Moreover, for the latter we devise the best possible resource augmentation result regarding speed: a polynomial time algorithm which computes a solution with \emph{optimal }cost at 1+ϵ1+\epsilon speedup. Finally, we present an elegant QPTAS for the special case where the cost functions of the jobs fall into at most logn\log n many classes. This algorithm allows the jobs even to have up to logn\log n many distinct release dates.Comment: 2 pages, 1 figur

    How unsplittable-flow-covering helps scheduling with job-dependent cost functions

    Get PDF
    Generalizing many well-known and natural scheduling problems, scheduling with job-specific cost functions has gained a lot of attention recently. In this setting, each job incurs a cost depending on its completion time, given by a private cost function, and one seeks to schedule the jobs to minimize the total sum of these costs. The framework captures many important scheduling objectives such as weighted flow time or weighted tardiness. Still, the general case as well as the mentioned special cases are far from being very well understood yet, even for only one machine. Aiming for better general understanding of this problem, in this paper we focus on the case of uniform job release dates on one machine for which the state of the art is a 4-approximation algorithm. This is true even for a special case that is equivalent to the covering version of the well-studied and prominent unsplittable flow on a path problem, which is interesting in its own right. For that covering problem, we present a quasi-polynomial time (1+ε)-approximation algorithm that yields an(e+ε)-approximation for the above scheduling problem. Moreover, for the latter we devise the best possible resource augmentation result regarding speed: a polynomial time algorithm which computes a solution withoptimalcost at1+εspeedup. Finally, we present an elegant QPTAS for the special case where the cost functions of the jobs fall into at mostlognmany classes. This algorithm allows the jobs even to have up tolognmany distinct release dates. All proposed quasi-polynomial time algorithms require the input data to be quasi-polynomially bounded

    Optimal Algorithms for Scheduling under Time-of-Use Tariffs

    Get PDF
    We consider a natural generalization of classical scheduling problems in which using a time unit for processing a job causes some time-dependent cost which must be paid in addition to the standard scheduling cost. We study the scheduling objectives of minimizing the makespan and the sum of (weighted) completion times. It is not difficult to derive a polynomial-time algorithm for preemptive scheduling to minimize the makespan on unrelated machines. The problem of minimizing the total (weighted) completion time is considerably harder, even on a single machine. We present a polynomial-time algorithm that computes for any given sequence of jobs an optimal schedule, i.e., the optimal set of time-slots to be used for scheduling jobs according to the given sequence. This result is based on dynamic programming using a subtle analysis of the structure of optimal solutions and a potential function argument. With this algorithm, we solve the unweighted problem optimally in polynomial time. For the more general problem, in which jobs may have individual weights, we develop a polynomial-time approximation scheme (PTAS) based on a dual scheduling approach introduced for scheduling on a machine of varying speed. As the weighted problem is strongly NP-hard, our PTAS is the best possible approximation we can hope for.Comment: 17 pages; A preliminary version of this paper with a subset of results appeared in the Proceedings of MFCS 201

    Non-uniform Geometric Set Cover and Scheduling on Multiple Machines

    Get PDF
    We consider the following general scheduling problem studied recently by Moseley. There are nn jobs, all released at time 00, where job jj has size pjp_j and an associated arbitrary non-decreasing cost function fjf_j of its completion time. The goal is to find a schedule on mm machines with minimum total cost. We give an O(1)O(1) approximation for the problem, improving upon the previous O(loglognP)O(\log \log nP) bound (PP is the maximum to minimum size ratio), and resolving the open question of Moseley. We first note that the scheduling problem can be reduced to a clean geometric set cover problem where points on a line with arbitrary demands, must be covered by a minimum cost collection of given intervals with non-uniform capacity profiles. Unfortunately, current techniques for such problems based on knapsack cover inequalities and low union complexity, completely lose the geometric structure in the non-uniform capacity profiles and incur at least an Ω(loglogP)\Omega(\log\log P) loss. To this end, we consider general covering problems with non-uniform capacities, and give a new method to handle capacities in a way that completely preserves their geometric structure. This allows us to use sophisticated geometric ideas in a black-box way to avoid the Ω(loglogP)\Omega(\log \log P) loss in previous approaches. In addition to the scheduling problem above, we use this approach to obtain O(1)O(1) or inverse Ackermann type bounds for several basic capacitated covering problems

    Geometry of Scheduling on Multiple Machines

    Get PDF
    We consider the following general scheduling problem: there are m identical machines and n jobs all released at time 0. Each job j has a processing time pj, and an arbitrary non-decreasing function fj that specifies the cost incurred for j, for each possible completion time. The goal is to find a preemptive migratory schedule of minimum cost. This models several natural objectives such as weighted norm of completion time, weighted tardiness and much more. We give the first O(1) approximation algorithm for this problem, improving upon the O(loglognP) bound due to Moseley (2019). To do this, we first view the job-cover inequalities of Moseley geometrically, to reduce the problem to that of covering demands on a line by rectangular and triangular capacity profiles. Due to the non-uniform capacities of triangles, directly using quasi-uniform sampling loses a O(loglogP) factor, so a second idea is to adapt it to our setting to only lose an O(1) factor. Our ideas for covering points with non-uniform capacity profiles (which have not been studied before) may be of independent int

    Optimal Algorithms for Scheduling under Time-of-Use Tariffs

    Get PDF
    We consider a natural generalization of classical scheduling problems in which using a time unit for processing a job causes some time-dependent cost which must be paid in addition to the standard scheduling cost. We study the scheduling objectives of minimizing the makespan and the sum of (weighted) completion times. It is not difficult to derive a polynomial-time algorithm for preemptive scheduling to minimize the makespan on unrelated machines. The problem of minimizing the total (weighted) completion time is considerably harder, even on a single machine. We present a polynomial-time algorithm that computes for any given sequence of jobs an optimal schedule, i.e., the optimal set of time-slots to be used for scheduling jobs according to the given sequence. This result is based on dynamic programming using a subtle analysis of the structure of optimal solutions and a potential function argument. With this algorithm, we solve the unweighted problem optimally in polynomial time. For the more general problem, in which jobs may have individual weights, we develop a polynomial-time approximation scheme (PTAS) based on a dual scheduling approach introduced for scheduling on a machine of varying speed. As the weighted problem is strongly NP-hard, our PTAS is the best possible approximation we can hope for
    corecore