Search

We investigate two parallel dedicated machine scheduling with conflict constraints. The problem of minimizing the makespan has been shown to be NP-hard in the strong sense under the assumption that the processing sequence of jobs on one machine is given and fixed a priori. The problem without any fixed sequence was previously recognized as weakly NP-hard. In this paper, we first present a 9 5 -approximation algorithm for the problem with a fixed sequence. Then we show that the tight approximation ratios of the algorithm are 7 4 and 5 3 for two subproblems which remain strongly NP-hard. We also send an improved algorithm with approximation ratio 3 − 2 ≈ 1.586 for one subproblem. Finally, we prove that the problem without any fixed sequence is actually strongly NP-hard, and design a 5 3 -approximation algorithm. • Consider the problem of scheduling with conflict constraints on two parallel dedicated machines. • Present a 9 5 -approximation algorithm for the strongly NP-hard case where jobs on one machine have a fixed processing sequence, and give improvements to its hard subproblems. • Prove that the problem without any fixed sequence is strongly NP-hard too and propose a 5 3 -approximation algorithm. [ABSTRACT FROM AUTHOR]

• We study the task utility maximization problem by scheduling mobile chargers and prove the NP-hardness of the problem. • We design three approximation algorithms for our problems, and prove the approximation ratio through theoretical analysis. • We validate the effectiveness of our algorithms by conducting extensive simulations. Replenishing energy to wireless sensor networks is always a crucial problem as the energy capacity of sensor nodes is very limited. Scheduling mobile chargers to charge sensor nodes has been widely studied due to its efficiency and flexibility. However, most existing works focus on maximizing the charging utility or charging efficiency, which ignores the task performing functions of sensor nodes. In this paper, we study the problem of scheduling a mobile charger to maximize the task utility achieved by sensor nodes. We consider two different scenarios where sensor nodes are deployed on a line road and a ring road, respectively. We prove the NP-Hardness of our problems and design two approximation algorithms with guaranteed performance. We also investigate how to jointly schedule two mobile chargers in the line road scenario, and design a corresponding approximation algorithm to address the problem. We prove the approximation ratio of our algorithms through theoretical analysis, and conduct extensive simulations to validate the performance of our algorithms. Simulation results show that our algorithms always outperform the baselines, which demonstrates the effectiveness of our algorithms. [ABSTRACT FROM AUTHOR]

We consider the single-machine time-dependent scheduling problem with linearly deteriorating jobs arriving over time. Each job i is associated with a release time r i and a processing time p i (s i) = α i + β i s i , where α i , β i > 0 are parameters and s i is the job's start time. In this setting, the approximability of both single-machine minimum makespan and total completion time problems remains open. We develop new bounds and approximation results for the special case of the problems with uniform deterioration, i.e. β i = β , for each i. The main contribution is a O (1 + 1 / β) -approximation algorithm for the makespan problem and a O (1 + 1 / β 2) approximation algorithm for the total completion time problem. Further, we propose greedy constant-factor approximation algorithms for instances with β = O (1 / n) and β = Ω (n) , where n is the number of jobs. Our analysis is based on an approach for comparing computed and optimal schedules via bounding pseudomatchings. [ABSTRACT FROM AUTHOR]

In crowdsourcing systems, a challenge arises in efficiently recruiting workers with unknown execution speed to complete tasks with precedence constraints within the shortest possible time. Recent research either only studies recruiting unknown workers or focuses on assigning tasks with precedence constraints, but few works consider both these factors. This paper aims to address this challenge considering all these factors by proposing a digital twin-assisted Combinatorial Multi-arm bandit based multi-round work Recruitment and task Scheduling (CMRS) scheme. Firstly, with the help of digital twin technology, we build digital twin models for crowdsourcing tasks and workers in digital twin layer of platform. And we formulate a Multi-round Workers recruitment and Task scheduling with Precedence constraints (MWTP) problem with the object of minimizing task completion time (makespan) to model the above challenging issue in crowdsourcing computing. The MWTP problem can be divided into two sub-problems, the task scheduling sub-problem and the worker recruitment sub-problem. Secondly, in the CMRS scheme, the differential evolution based task scheduling (DETS) algorithm and CUCB-based worker recruitment (CWR) method are proposed to solve them, respectively. Specifically, for the task scheduling sub-problem, we first propose a priority-driven based task scheduling (PDTS) approximation algorithm to produce a primary solution with an explicit approximation ratio. Then a DETS algorithm is proposed to use the solution of PDTS for initialization and generate a better solution that further improves the performance. For the unknown workers recruitment sub-problem, we use the Combinatorial Multi-Arm Bandit framework to model this, and propose CWR method to learn the computational capabilities of workers while maintaining good performance during multiple rounds of worker recruitment by adding a tuning term to balanced exploration and exploitation. Finally, verified by extensive comparison experiments, the CMRS scheme can achieve the best performance of makespan compared with the baselines in most cases. [ABSTRACT FROM AUTHOR]

• Research was motivated from recent research in cloud computing. • A new model for research on scheduling of multiple processors. • Computational complexity of the proposed scheduling problems. • Approximation algorithms for the proposed scheduling problems. • Relationship between the proposed scheduling problems and multiple knapsack packing. Recently, motivated by applications in cloud computing, scheduling multiple two-stage flowshops with the objective of minimizing the makespan has drawn increasing attention. Motivated by the same applications, the current paper studies the problem of scheduling multiple two-stage flowshops with a deadline, with the objective of maximizing the profit of the jobs that can be completed by the deadline. Algorithms and complexity of the problem are investigated. For the case where the number of two-stage flowshops is part of the input, we present an efficient approximation algorithm with a constant ratio. The approximation ratio is improved via a study of the relationship between the problem and the multiple knapsack problem, combined with the recent progresses in the research in approximation algorithms for the multiple knapsack problem. By integrating techniques in the study of the classical Knapsack problem and the classical Makespan problem on multiple processors, plus additional new techniques, a polynomial-time approximation algorithm with a further improved approximation ratio is developed for the case where the number of flowshops is a fixed constant. [ABSTRACT FROM AUTHOR]

We investigate the recoverable robust single machine scheduling problem under interval uncertainty. In this setting, jobs have first-stage processing times p and second-stage processing times q and we aim to find a first-stage and second-stage schedule with a minimum combined sum of completion times, such that at least Δ jobs share the same position in both schedules. We provide positive complexity results for some important special cases of this problem, as well as derive a 2-approximation algorithm to the full problem. Computational experiments examine the performance of an exact mixed-integer programming formulation and the approximation algorithm, and demonstrate the strength of a proposed polynomial time greedy heuristic. [ABSTRACT FROM AUTHOR]

The coordination among drones and ground vehicles for last-mile delivery has gained significant interest in recent years. In this paper, we study multiple drone delivery scheduling problem (MDSP) [1] for last-mile delivery, where we have a set of drones with an identical battery budget and a set of delivery locations; along with profit for delivery, cost, and delivery time intervals. The objective of the MDSP is to find conflict-free schedules for each drone such that the total profit gained is maximum subject to the battery constraint of the drones. This paper proposes an optimal pseudo-polynomial algorithm and a fully polynomial time approximation scheme (FPTAS) for the single drone delivery scheduling problem (SDSP). Also, we propose two approximation algorithms of factor 1 3 for the MDSP with some constraints on the number of drones. We formulate the problem for the heterogeneous case, where the drones have non-identical battery capacities, and propose a 1 6 ρ -approximation algorithm, where ρ is the ratio between the minimum and maximum battery capacity of the drones. • An optimal pseudo-polynomial algorithm and FPTAS for the single drone delivery scheduling problem is proposed. • Two approximation algorithms for the multiple drone delivery scheduling problem are proposed. • An approximation algorithm for the multiple heterogeneous drone delivery scheduling problem is proposed. • We analyzed the approximation factors of all the aforementioned proposed algorithms and time complexities. [ABSTRACT FROM AUTHOR]

• Scheduling problem with different types of calibrations on a single machine. • Two models are considered: jobs have agreeable deadlines and calibrations costs are agreeable. • Constant approximation algorithms are given. Machines usually require maintenance after running a fixed period. A calibration at a cost has to be performed during the process. Finding a feasible schedule minimizing the total cost of calibrations is of great importance. In this paper, we deal with a single machine scheduling model with K types of calibrations. A calibration of type k ∈ { 1 , ... , K } can be made instantaneously at any time point, which incurs a cost f k and can keep the machine active for a length T k. Given a set of n jobs with release times, deadlines, and processing times, the goal is to minimize the total cost of calibrations by assigning all jobs in the calibrated state, where job preemption is allowed. We investigate two agreeable settings. Regarding agreeable jobs, later release times imply later deadlines. We establish a pseudo-polynomial time optimal algorithm and a (3 + ε) -approximation algorithm. Moreover, if the largest job processing time is no more than any calibration length, it admits a (2 + ε) -approximation algorithm. As for agreeable calibrations, where the cost of each calibration is proportional to its length, a 2-approximation algorithm is presented. [ABSTRACT FROM AUTHOR]

We consider a two-stage production scheduling problem where each operation can be outsourced or processed in-house. For each operation in the same machine, the ratio of its outsourcing cost to its processing time is constant. The objective is to minimize the sum of the makespan and the total outsourcing cost. It is known that this problem is either polynomial time solvable or NP-hard according to the conditions of the ratios. Even though approximation algorithms for NP-hard cases had been developed, their tight worst-case performance ratios are still open. In this paper, we carefully analyze the approximation algorithms to identify their tight worst-case performance ratios for cases. In one case, we propose a new approximation algorithm with a better and tight worst-case performance ratio. In the process of analyzing the algorithm, we propose a technique utilizing nonlinear optimization. [ABSTRACT FROM AUTHOR]

• Scheduling problem on m identical speed scalable processors with shared memory is considered. • A constant approximation algorithm is given. • An optimal algorithm is given when assignment of jobs is fixed. Energy efficiency is a crucial desideratum in the design of computer systems, from small-sized mobile devices with limited battery to large scale data centers. In such computing systems, processors and memory are considered as two major power consumers among all the system components. One recent trend to reduce power consumption is using shared memory in multi-core systems, such architecture has become ubiquitous nowadays. However, implementing the energy-efficient methods to the multi-core processor and the shared memory separately is not trivial. In this work, we consider the energy-efficient task scheduling problem, which coordinates the power consumption of both the multi-core processor and the shared memory, especially focus on the general situation in which the number of tasks is more than the number of cores. We devise an approximation algorithm with guaranteed performance in the multiple cores system. We tackle the problem by first presenting an optimal algorithm when the assignment of tasks to cores is given. Then we propose an approximation assignment for the general task scheduling. [ABSTRACT FROM AUTHOR]

We consider the multi organization scheduling problem (MOSP) [19] : given N organizations owning, each of them, one set of tasks and machines, the aim is to compute a schedule which gathers all the tasks on all the machines, and such that the makespan is minimized. A rationality constraint must be fulfilled: no organization should increase its makespan (the completion time of its last task) compared to the case where it schedules its own tasks (and only its own tasks) on its own machines. We show that cooperation (sharing machines and tasks) can benefit to all the organizations simultaneously, since they may decrease their makespans by a factor of N. We present an algorithm which is (1 + ϵ) -approximate, while the makespan of each organization is increased by a factor at most (1 + ϵ). We also study to which extent the rationality constraint (or a relaxed constraint) increases the makespan, compared to problem (P | | C max) where there is no such a constraint. Finally, we introduce a new problem, which focus on equity: the aim is to return a schedule which fulfills the rationality constraint and which maximizes the factor by which each organization has decreased its makespan. We give an optimal algorithm for this problem in a particular case, and show that it is NP-hard and hard to approximate in the general case. We complete this paper by an efficient heuristic for this problem. • We study cooperation in grids, or in settings where users share tasks and machines. • We consider the multi organization scheduling problem and a relaxation of it. • We study the tradeoff between makespan minimization and satisfaction of the users. • We are interested by fairness between users (or agents). • We give approximate algorithms with performance guarantee and heuristics. [ABSTRACT FROM AUTHOR]

This paper investigates two flow shop scheduling problems with two machines A and B , and a single transporter V. In the first problem, the transporter V is located at machine A initially, each job has to be processed first on A , then transported to B for further processing. While in the second problem, the transporter V is located at machine B initially, each job needs to be processed first on A , then on B , finally transported to the destination. In both problems, the transporter V can carry up to c (where c is a constant and c ≥ 1) jobs at a time and the objective is to minimize the makespan. For the former problem, the best approximation algorithm guarantees a worst-case ratio bound of (5 3 + ε) , while for the latter one, the best approximation algorithm provides a worst-case ratio bound of 2. For each problem, we design a polynomial-time approximation scheme (PTAS). [ABSTRACT FROM AUTHOR]

In the Multi-Spreader Crane Scheduling Problem (MSCSP), containers with identical dimensions but variable weights are arranged along a grid. A multi-spreader crane is used to lift all the containers. The crane has m > 1 modes. When it is in the p th mode, the crane can remove p adjacent containers along the same row at the same time as long as the total weight of the containers does not exceed the loading capacity κ p. Such a lift takes h p minutes. It also takes c p , q minutes for the crane to switch from mode p to q when p ≠ q. The goal is to find a crane lift sequence so that the total time it takes to lift all the containers is minimized. This paper investigates the computational complexity of MSCSP. First, we establish a connection between greedy crane lift sequences and supersequences. We then prove that MSCSP is NP-hard when the crane has three or more modes by a reduction from a version of the Shortest Common Supersequence problem. Lastly, we investigate two problems that arise naturally when heuristics are used to solve MSCSP. We show that one can be solved using dynamic programming while the other remains computationally hard. We also provide an approximation algorithm that behaves nicely when the changeover times are not much larger than the lifting times of the crane. [ABSTRACT FROM AUTHOR]

The general position-dependent scheduling problems are studied in this paper. A 2-approximation algorithm is proposed for the learning scheduling problem on a single machine with release time to minimize the makespan. To minimize the total completion time on a single machine with release time and learning effect, we design a 2-approximation algorithm and a P T A S. Moreover, for the deteriorating scheduling problem to minimize the makespan on parallel machines, a 2-approximation algorithm is provided. [ABSTRACT FROM AUTHOR]

We consider scheduling on identical and unrelated parallel machines with job assignment restrictions. These problems are NP-hard and they do not admit polynomial time approximation algorithms with approximation ratios smaller than 1.5 unless P=NP. However, if we impose limitations on the set of machines that can process a job, the problem sometimes becomes easier in the sense that algorithms with approximation ratios better than 1.5 exist. We introduce a graph framework based on the assignment restrictions and study the computational complexity of the scheduling problem with respect to structural properties of the resulting graphs, in particular, their tree- and cliquewidth. We identify cases that admit polynomial time approximation schemes or FPT algorithms generalizing and extending previous results in this area. [ABSTRACT FROM AUTHOR]

We consider the problem of scheduling jobs with sizes, release times and delivery times on identical parallel batch machines. All machines have the same capacity. Each machine can simultaneously process several jobs as a batch as long as the total size of these jobs does not exceed the capacity. The release time, processing time and delivery time of a batch are defined to be the latest release time, longest processing time and largest delivery time of all the jobs in the batch, respectively. The objective is to minimize the maximum delivery completion time, i.e., the time by which all jobs are delivered. For this strongly NP-hard problem, there does not exist any polynomial time algorithm with approximation ratio better than 2 unless P=NP, even if all jobs have equal processing times and all release times and delivery times are zero. We present an algorithm with approximation ratio arbitrarily close to 2. • Study parallel batch scheduling of minimizing maximum delivery completion time. • Jobs have non-identical sizes, release times and delivery times. • Present an algorithm with approximation ratio arbitrarily close to 2. [ABSTRACT FROM AUTHOR]

We study the scheduling problem with calibrations. We are given a set of n jobs that need to be scheduled on a set of m machines. However, a machine can schedule jobs only if a calibration has been performed beforehand and the machine is considered as valid during a fixed time period of T , after which it must be recalibrated before running more jobs. In this paper, we investigate the batch calibrations; calibrations occur in batch and at the same moment. It is then not possible to perform any calibrations during a period of T. We consider different cost function depending on the number of machines we calibrate at a given time, i.e., the cost function is denoted as f (x) where x is the number of calibrations in the batch. Moreover, jobs have release time, deadline, and unit processing time. The objective is to schedule all jobs with the minimum cost of calibrations. We give a dynamic program to solve the case with an arbitrary cost function. Then, we propose several faster approximation algorithms for different cost functions: an optimal algorithm when f (x) = b , a 3-approximation algorithm when f (x) = x and a (m + b) / (b + 1) -approximation algorithm when f (x) = x + b. The running time of these algorithms are O (n 2). [ABSTRACT FROM AUTHOR]

Let there be a set M of m parallel machines and a set J of n jobs, where each job j takes p i , j time units on machine M i. In makespan minimization the goal is to schedule each job non-preemptively on a machine such that the length of the schedule, the makespan, is minimum. We investigate a generalization of makespan minimization on unrelated parallel machines (R | | C m a x) where J is partitioned into b bags B = (B 1 , ... , B b) , and no two jobs belonging to the same bag can be scheduled on the same machine. First we present a simple b -approximation algorithm for R | | C m a x with bags (R | b a g | C m a x). We also give a polynomial-time approximation scheme (PTAS) for R | b a g | C m a x with machine types where both the number of machine types and bags are constant; two machines M i and M i ′ have the same machine type if p i , j = p i ′ , j for all j ∈ J. This result infers the existence of a PTAS for uniform parallel machines (Q | b a g | C m a x) when the number of machine speeds and number of bags are both constant. Then, we present a b / 2 -approximation algorithm for the graph balancing problem with b ≥ 2 bags; the approximation ratio is tight for b = 3 , unless P = NP , and this algorithm solves the graph balancing problem with b = 2 bags in polynomial time. In addition, we present a polynomial-time algorithm for the restricted assignment problem on uniform parallel machines with bags when all the jobs have unit length. To complement our algorithmic results, we show that when the jobs have lengths 1 or 2 it is NP -hard to approximate the optimum makespan within a factor smaller than 3/2 for both the restricted assignment and graph balancing problems with b = 2 bags and b = 3 bags, respectively. We also prove that Q | b a g | C m a x with b = 2 bags is strongly NP -hard. [ABSTRACT FROM AUTHOR]

• Polynomial time algorithm for the discrete speed model and fixed order of jobs. • Polynomial time algorithm for the sense-and-aggregate model. • Heuristic for the continuous speed model for arbitrary order of jobs. We study the following flow shop scheduling problem on two processors. We are given n jobs with a common deadline D , where each job j has workload p i , j on processor i and a set of processors which can vary their speed dynamically. Job j can be executed on the second processor if the execution of job j is completed on the first processor. Our objective is to find a feasible schedule such that all jobs are completed by the common deadline D with minimized energy consumption. For this model, we present a linear program for the discrete speed case, where the processor can only run at specific speeds in S = { s 1 , s 2 , ⋯ , s q } and the job execution order is fixed. We also provide a m α − 1 -approximation algorithm for the arbitrary order case and for continuous speed model where m is the number of processors and α is a parameter of the processor. We then introduce a new variant of flow shop scheduling problem called sense-and-aggregate model motivated by data aggregation in wireless sensor networks where the base station needs to receive data from sensors and then compute a single aggregate result. In this model, the first processor will receive unit size data from sensors and the second processor is responsible for calculating the aggregate result. The second processor can decide when to aggregate and the workload that needs to be done to aggregate x data will be f (x) and another unit size data will be generated as the result of the partial aggregation which will then be used in the next round aggregation. Our objective is to find a schedule such that all data are received and aggregated by the deadline with minimum energy consumption. We present an O (n 5) dynamic programming algorithm when f (x) = x and a greedy algorithm when f (x) = x − 1. Finally, we investigate the performance of the flowshop problem when the order of jobs is fixed by comparing it to the approximation algorithm with an arbitrary order. We show experimentally that the approximation ratio is close to 1 when there are few machines and when there are more jobs. [ABSTRACT FROM AUTHOR]

This paper studies the problem of scheduling n two-stage jobs on m multiple two-stage flowshops, with the objective of minimizing the makespan. The problem is NP-hard even when m is a fixed constant, and becomes strongly NP-hard when m is part of the input. A 2.6-approximation algorithm along with its analysis is presented for an arbitrary m ≥ 2. This is the first approximation algorithm for multiple flowshops when the number m of flowshops is part of the input. The fact that m is part of the input and the time complexity O (n log ⁡ n) of the algorithm demonstrate that the problem, which plays an important role in the current research in cloud computing and data centers, can be solved efficiently with a reasonable level of satisfaction. • The paper is motivated by current research in data centers and cloud computing, and addresses an important optimization problem in the area. • The paper gives the first approximation algorithm for scheduling two-stage jobs on m multiple two-stage flowshops, where m is part of the input. • The paper introduces a technique of the "cutting job" so that the completion time of a flowshop can be expressed precisely in terms of the cutting job. • The 2.6-approximation algorithm in the current paper, which runs in time O (n log ⁡ n) for an arbitrary m , provides an efficient solution in practice. [ABSTRACT FROM AUTHOR]

• This relationship between the multiple two-stage flowshops problem and the classical MAKESPAN problem is studied. • If the MAKESPAN problem has an α -approximation algorithm, then the problem has a 2 α -approximation algorithm. • Two restricted cases of the problem, which are of practical importance, have an (α + 1 / 2)-approximation algorithm. • The approximation ratios 2.6 for the problem and 11/6 for two restricted cases are improved to 2 + ϵ and 1.5 + ϵ respectively. This paper considers the problem of scheduling n two-stage jobs on m two-stage flowshops so as to minimize the makespan. By studying the relationship between the problem and the classical makespan problem, we prove that if there is an α -approximation algorithm for the makespan problem, then for the general case of the problem, we can construct a 2 α -approximation algorithm, and for two restricted cases which are of practical importance, we can construct an (α + 1 / 2) -approximation algorithm. As a result, by employing the polynomial-time approximation scheme for the makespan problem, we get a (2 + ϵ) -approximation algorithm for the general case and a (1.5 + ϵ) -approximation algorithm for the two restricted cases, which significantly improve the previous approximation ratios 2.6 and 11/6 respectively. [ABSTRACT FROM AUTHOR]

We study open-shop scheduling for unit jobs under precedence constraints, where if one job precedes another job then it has to be finished before the other job can start to be processed. For the three-machine open-shop to minimize the makespan, we first present a simple 5/3-approximation algorithm based on a partition of the job set into agreeable layers using the natural layered representation of the precedence graph, which is directed acyclic. We then show a greedy algorithm to reduce the number of singleton-job layers, resulting in an improved partition, which leads to a 4/3-approximation algorithm. Both approximation algorithms apply to the general m -machine open-shops too. [ABSTRACT FROM AUTHOR]

A mixed shop is a manufacturing infrastructure designed to process a mixture of a set of flow-shop jobs and a set of open-shop jobs. Mixed shops are in general much more complex to schedule than flow-shops and open-shops, and have been studied since the 1980's. We consider the three machine proportionate mixed shop problem denoted as M 3 | p r p t | C max , in which by "proportionate" each job has equal processing times on all three machines. Koulamas and Kyparisis (2015) [6] showed that the problem is solvable in polynomial time in some very special cases; for the non-solvable case, they proposed a 5/3-approximation algorithm. In this paper, we first present an improved 4/3-approximation algorithm and show that this ratio of 4/3 is asymptotically tight; when the largest job is a flow-shop job, we then present a fully polynomial-time approximation scheme (FPTAS). On the negative side, while the F 3 | p r p t | C max problem is polynomial-time solvable, we show an interesting hardness result that adding one open-shop job to the job set makes the problem NP-hard if this open-shop job is larger than any flow-shop job. We are able to design an FPTAS for this special case too. [ABSTRACT FROM AUTHOR]

We study scheduling on multiple two-stage flowshops in which each job has to pass through an R -operation and a T -operation. Motivated by the current research in data centers, we consider two restricted versions of the problem in which the jobs are inclined: one restricts that for each job, the R -operation consumes no less time than the T -operation, while the other assumes that the T -operation consumes no less time than the R -operation for each job. For the first case, we present an online 2-competitive algorithm and an offline 11/6-approximation algorithm. For the second case, we give an online 5/2-competitive algorithm, and prove, for the offline setting, that the problem can be reduced to the problem in the first case. • This paper studies the problem of scheduling two-stage jobs on m multiple two-stage flowshops to minimize the makespan, where m is part of the input. • Motivated by practical applications in data centers, we study two restricted versions of the problem where both versions are strongly NP-hard. • For the case where each job has its R -time no smaller than its T -time, we present a 2-competitive algorithm and an 11/6-approximation algorithm. • For the case where each job has its T -time no smaller than its R -time, we give a 5/2-competitive algorithm and an 11/6-approximation algorithm. • To the best of our knowledge, this paper is the first that studies the scheduling problem on m two-stage flowshops where m is part of the input. [ABSTRACT FROM AUTHOR]

We consider the problem of scheduling independent jobs with a common due date on a single machine with the objective of maximizing the number of early jobs. The processing times are uncertain and take any value from a certain job dependent interval. For measuring the quality of an algorithm for that problem with imprecise data we use the concept of minimizing the maximum regret. We present complexity results and some dominance properties. [ABSTRACT FROM AUTHOR]

We formulate and study a fundamental search and detection problem, Schedule Optimization , motivated by a variety of real-world applications, ranging from monitoring content changes on the web, social networks, and user activities to detecting failure on large systems with many individual machines. We consider a large system consists of many nodes, where each node has its own rate of generating new events, or items. A monitoring application can probe a small number of nodes at each step, and our goal is to compute a probing schedule that minimizes the expected number of undiscovered items at the system, or equivalently, minimizes the expected time to discover a new item in the system. We study the Schedule Optimization problem both for deterministic and randomized memoryless algorithms. We provide lower bounds on the cost of an optimal schedule and construct close to optimal schedules with rigorous mathematical guarantees. [ABSTRACT FROM AUTHOR]

In this work we study min max robust scheduling problems assuming that the processing times can take any value in the budgeted uncertainty set introduced by Bertsimas and Sim (2003, 2004). We consider problems on a single machine that minimize the (weighted and unweighted) sum of completion times and problems that minimize the makespan on parallel and unrelated machines. We provide approximation algorithms: constant factor, average non-constant factor, (fully or not) polynomial time approximation schemes. In addition, we prove that the robust version of minimizing the weighted completion time on a single machine is NP -hard in the strong sense. [ABSTRACT FROM AUTHOR]

Abstract We consider parallel machine scheduling with job assignment restrictions, i.e., each job can only be processed on a certain subset of the machines. Moreover, each job requires a set of renewable resources. Any resource can be used by only one job at any time. The objective is to minimize the makespan. We present approximation algorithms with constant worst-case bound in the case that each job requires only a fixed number of resources. For some special cases optimal algorithms with polynomial running time are given. If any job requires at most one resource and the number of machines is fixed, we give a PTAS. On the other hand we prove that the problem is APX -hard, even when there are just three machines and the input is restricted to unit-time jobs. [ABSTRACT FROM AUTHOR]

Linear model predictive control is extended to both control and optimize a product grade schedule. The proposed methods are time-scaling of the linear dynamics based on throughput rates and grade-based objectives for product scheduling based on a mathematical program with complementarity constraints. The linear model is adjusted with a residence time approximation to time-scale the dynamics based on throughput. Although nonlinear models directly account for changing dynamics, the model form is restricted to linear differential equations to enable fast online cycle times for large-scale and real-time systems. This method of extending a linear time-invariant model for scheduling is designed for many advanced control applications that currently use linear models. Simultaneous product switching and grade target management is demonstrated on a reactor benchmark application. The objective is a continuous form of discrete ranges for product targets and economic terms that maximize overall profitability. [ABSTRACT FROM AUTHOR]

In this paper we study parallel-machine scheduling with job rejection, where the total processing time of the rejected jobs is required to be no greater than a predefined bound. The objective is to minimize the makespan of the accepted jobs plus the total penalty cost of the rejected jobs. The scheduling problem is NP-hard in the strong sense. We present a 2-approximation algorithm with a time complexity of O ( n log ⁡ n ) by making use of specific data structure. We also develop a polynomial time approximation scheme (PTAS). Due to the job rejection restriction, some techniques for knapsack problems are applied in the development of our PTAS. [ABSTRACT FROM AUTHOR]

In the classical interval scheduling type of problems, a set of n jobs, characterized by their start and end time, needs to be executed by a set of machines, under various constraints. In this paper we study a new variant in which the jobs need to be assigned to at most k identical machines, such that the minimum number of machines that are busy at the same time is maximized. This is relevant in the context of genome sequencing and haplotyping, specifically when a set of DNA reads aligned to a genome needs to be pruned so that no more than k reads overlap, while maintaining as much read coverage as possible across the entire genome. We show that the problem can be solved in time min O ( n 2 log k ∕ log n ) , O ( n k log k ) by using max-flows. We also give an O ( n log n ) -time approximation algorithm with approximation ratio ρ = k ⌊ k ∕ 2 ⌋ . [ABSTRACT FROM AUTHOR]

We study a problem of optimal bandwidth allocation in the elastic optical networks technology, where usable frequency intervals are of variable width. In this setting, each lightpath has a lower and upper bound on the width of its frequency interval, as well as an associated profit, and we seek a bandwidth assignment that maximizes the total profit. This problem is known to be NP-complete. We strengthen this result by showing that, in fact, the problem is inapproximable within any constant ratio even on a path network. We further derive NP-hardness results and present approximation algorithms for several special cases of the path and ring networks, which are of practical interest. Finally, while in general our problem is hard to approximate, we show that an optimal solution can be obtained by allowing resource augmentation . Some of our results resolve open problems posed by Shalom et al. (2013) [28] . Our study has applications also in real-time scheduling. [ABSTRACT FROM AUTHOR]

We consider the problem of minimizing the makespan of a schedule on m parallel machines of n jobs, where each job requires exactly one of s additional unit resources. This problem collapses to P ∥ C max if every job requires a different resource. It is therefore NP-hard even if we fix the number of machines to 2 and strongly NP-hard in general. Although very basic, its approximability is not known, and more general cases, such as scheduling with conflicts , are often not approximable. We give a ( 2 − 2 m + 1 ) -approximation algorithm for this problem, and show that when the deviation in jobs processing times is bounded by a ratio ρ , the same algorithm approximates the problem within a tight factor 1 + ρ ( m − 1 ) n . This problem appears in the design of download plans for Earth observation satellites, when scheduling the transfer of the acquired data to ground stations. Within this context, it may be required to process jobs by batches standing for the set of files related to a single observation. We show that there exists a ( 2 − 1 m ) -approximation algorithm respecting such batch sequences. Moreover, provided that the ratio ρ , between maximum and minimum processing times, is bounded by ⌊ s − 1 m − 1 ⌋ , we show that the proposed algorithm approximates the optimal schedule within a factor 1 + s − 1 n . [ABSTRACT FROM AUTHOR]

In this paper, we investigate the symbiosis between a truck and multiple drones in a last-mile package delivery scenario, introducing the Scheduling Conflictual Deliveries Problem (SCDP). From the main depot, a truck takes care of transporting a fleet of drones that will be used to deliver packages to customers. The route of the truck is predefined. Each delivery is associated with the energy cost of a drone, a reward that characterizes the priority of the delivery, and an interval between two points of the truck's route: the point from which the drone departs (launch point) and the point at which the drone returns to the truck (rendezvous point). The objective of the SCDP is to find a scheduling for the drones that maximizes the overall reward subject to the drone's battery capacity while ensuring that the same drone performs deliveries whose delivery intervals do not intersect. After showing that SCDP is an NP-hard problem, we devise an Integer Linear Programming (ILP) formulation for it. Furthermore, we devise a pseudo-polynomial time optimal algorithm for the single drone case and additional approximation algorithms for both the single and multiple drones case. Finally, we thoroughly compare the performances of our presented algorithms on different synthetic datasets. [ABSTRACT FROM AUTHOR]

Demand Response (DR) is a widely used technique to minimize the peak to average consumption ratio during high demand periods. We consider the DR problem of achieving a given curtailment target for a set of consumers equipped with a set of discrete curtailment strategies over a given duration. An effective DR scheduling algorithm should minimize the curtailment error - the difference between the targeted and achieved curtailment values - to minimize costs to the utility provider and maintain system reliability. The availability of smart meters with fine-grained customer control capability can be leveraged to offer customers a dynamic range of curtailment strategies that are feasible for small durations within the overall DR event. Both the availability and achievable curtailment values of these strategies can vary dynamically through the DR event and thus the problem of achieving a target curtailment over the entire DR interval can be modeled as a dynamic strategy selection problem over multiple discrete sub-intervals. We argue that DR curtailment error minimizing algorithms should not be oblivious to customer curtailment behavior during sub-intervals as (expensive) demand peaks can be concentrated in a few sub-intervals while consumption is heavily curtailed during others in order to achieve the given target, which makes such solutions expensive for the utility. Thus in this paper, we formally develop the notion of Sustainable DR (SDR) as a solution that attempts to distribute the curtailment evenly across sub-intervals in the DR event. We formulate the SDR problem as an Integer Linear Program and provide a very fast $\sqrt{2}$-factor approximation algorithm. We then propose a Polynomial Time Approximation Scheme (PTAS) for approximating the SDR curtailment error to within an arbitrarily small factor of the optimal. We then develop a novel ILP formulation that solves the SDR problem while explicitly accounting for customer strategy switching overhead as a constraint. We perform experiments using real data acquired from the University of Southern California’s smart grid and show that our sustainable DR model achieves results with a very low absolute error of 0.001-0.05 kWh range. [ABSTRACT FROM AUTHOR]

We consider the problem of partitioning interval graphs into cliques of bounded size. Each interval has a weight, and the weight of a clique is the maximum weight of any interval in the clique. The goal is then to find such a partition of minimum total weight. This graph problem can also be interpreted as a batch scheduling problem. Solving a long-standing open question, we show NP-hardness, even if the bound on the clique sizes is constant. Moreover, we give a PTAS for this case. [ABSTRACT FROM AUTHOR]

For many years, scheduling problems have been concerned either with parallel processor systems or with dedicated processors—job shop type systems. With a development of new computing architectures this partition is no longer so obvious. Multi-core (processor) computers equipped with GPU co-processors require new scheduling strategies. This paper is devoted to a characterization of this new type of scheduling problems. After a thorough introduction of the new model of a computing system, an extension of the classical notation of scheduling problems is proposed. A special attention is paid to preemptions, since this feature of the new architecture differs the most as compared with the classical model. In the paper, several scheduling algorithms, new ones and those refining classical approaches, are presented. Possible extensions of the model are also discussed. [ABSTRACT FROM AUTHOR]

We consider a version of parallel machine scheduling with rejection. An instance of the problem is given by m identical parallel machines and a set of n independent jobs, with each job having a processing time and a penalty. A job may be accepted to be processed or be rejected at its penalty. The objective of the problem is to partition the set of jobs into two subsets, the subset of accepted and the subset of rejected jobs, and to schedule the set of accepted jobs such that the makespan is minimized under the constraint that the total penalty of the rejected jobs is no more than a given bound. In this paper, we present a 2-approximation algorithm within strongly polynomial time for the problem. We also present a polynomial time approximation scheme whose running time is O ( n m O ( 1 ϵ 2 ) + mn 2 ) for the problem. Moreover, for the case where the number of machines is a fixed constant m , our results lead to a fully polynomial time approximation scheme for the problem. Our result is fairly good in the sense that in a reasonable size of jobs, our FPTAS improves previous best running time from O ( n m + 2 / ϵ m ) to O ( 1 / ϵ 2 m + 3 + mn 2 ) . [ABSTRACT FROM AUTHOR]

The Multiple Cluster Scheduling Problem corresponds to minimizing the maximum completion time (makespan) of a set of n parallel rigid (and non-preemptive) jobs submitted to N identical clusters. It cannot be approximated with a ratio better than 2 (unless P = NP ). We present in this paper the methodology that encompasses several existing results [1,2] . We detail first how to apply it for obtaining a 5 2 -approximation. Then, we use it to provide a new 7 3 -approximation running in O ( log ⁡ ( n h max ) N ( n + log ⁡ ( n ) ) ) , where h max is the processing time of the longest job. Finally, we apply it to a restriction of the problem to jobs of limited size, leading to a 2-approximation which is the best possible ratio since the restriction remains 2-inapproximable. [ABSTRACT FROM AUTHOR]

We consider the problem of scheduling jobs in batches on a single machine where the processing time of each job is a simple increasing linear function of its waiting time, i.e., the time between the starting time of processing the batch to which the job belongs and the starting time of processing of the job. The objective is to minimize the sum of the total job flow time and the batching cost. We first show that the case with a given number of batches is strongly NP-hard and we present a fully polynomial-time approximation scheme (FPTAS) for this case. We then show that the case with an arbitrary number of batches is also strongly NP-hard and there is no polynomial-time approximation algorithm with a constant upper bound for this case unless P = NP . [ABSTRACT FROM AUTHOR]

We are given a set of jobs, each one specified by its release date, its deadline and its processing volume (work), and a single (or a set of) speed-scalable processor(s). We adopt the standard model in speed-scaling in which if a processor runs at speed s then the energy consumption is sα units of energy per time unit, where α > 1 is a small constant. Our goal is to find a schedule respecting the release dates and the deadlines of the jobs so that the total energy consumption to be minimized. While most previous works have studied the preemptive case of the problem, where a job may be interrupted and resumed later, we focus on the non-preemptive case where once a job starts its execution, it has to continue until its completion without any interruption. As the preemptive case is known to be polynomially solvable for both the single-processor and the multiprocessor case, we explore the idea of transforming an optimal preemptive schedule to a non-preemptive one. We prove that the preemptive optimal solution does not preserve enough of the structure of the non-preemptive optimal solution, and more precisely that the ratio between the energy consumption of an optimal non-preemptive schedule and the energy consumption of an optimal preemptive schedule can be very large even for the single-processor case. Then, we focus on some interesting families of instances: (i) equal-work jobs on a single-processor, and (ii) agreeable instances in the multiprocessor case. In both cases, we propose constant factor approximation algorithms. In the latter case, our algorithm improves the best known algorithm of the literature. Finally, we propose a (non-constant factor) approximation algorithm for general instances in the multiprocessor case. [ABSTRACT FROM AUTHOR]

The Quantum Circuit Compilation Problem (QCCP) is challenging to the Artificial Intelligence community. It was already tackled with temporal planning, constraint programming, greedy heuristics and other techniques. In this paper, QCCP is formulated as a scheduling problem and solved by a genetic algorithm. We focus on QCCP for Quantum Approximation Optimization Algorithms (QAOA) applied to the MaxCut problem and consider Noisy Intermediate Scale Quantum (NISQ) hardware architectures. Based on the fact that these algorithms apply a set of basic quantum operations repeatedly over a number of rounds, we propose a genetic algorithm approach, termed Decomposition Based Genetic Algorithm (DBGA), that in each round extends the partial solutions obtained for the previous ones. DBGA is compared to the state of the art across a set of conventional instances. The results of the experimental study provided interesting insight in the problem structure and showed that DBGA is quite competitive with the state of the art. In particular, DBGA outperformed the best current method on the largest instances and provided new best solutions to most of them. [ABSTRACT FROM AUTHOR]

Abstract: In this paper, we consider the selective graph coloring problem. Given an integer and a graph with a partition of V, it consists in deciding whether there exists a set in G such that for all , and such that the graph induced by is k-colorable. We investigate the complexity status of this problem in various classes of graphs. [Copyright &y& Elsevier]

Abstract: This paper is the first attempt to successfully design efficient approximation algorithms for the single-machine maximum lateness minimization problem when jobs have different release dates and tails (or delivery times) under the no idle time assumption (i.e., the schedule cannot contain any idle time between two consecutive jobs on the machine). Our work is motivated by interesting industrial applications to the production area (Chrétienne (2008) [3]). Our analysis shows that modifications of the classical algorithms of Potts and Schrage can lead to the same worst-case performance ratios obtained for the relaxed problem without the no idle time constraint. Then, we extend the result developed by Mastrolilli (2003) [13] for such a relaxed problem and we propose a polynomial time approximation scheme with efficient time complexity. [Copyright &y& Elsevier]

Abstract: Matching problems on bipartite graphs where the entities on one side may have different sizes are intimately related to scheduling problems with processing set restrictions. We survey the close relationship between these two problems, and give new approximation algorithms for the (NP-hard) variations of the problems in which the sizes of the jobs are restricted. Specifically, we give an approximation algorithm with an additive error of one when the sizes of the jobs are either 1 or 2, and generalise this to an approximation algorithm with an additive error of for the case where each job has a size taken from the set (for any constant integer ). We show that the above two problems become polynomial-time solvable if the processing sets are nested. [Copyright &y& Elsevier]

Abstract: This paper deals with a parallel machine scheduling problem. Different from fixed processing time assumption in the classical scheduling, a job’s processing time is a simple linear increasing function of its starting time. The aim is makespan minimization, and our focus is on the case with an arbitrary number of parallel machines. We prove that LIST rule is -approximation where is the number of machines and is the maximum deteriorating rate of job. We then propose one heuristic LDR (Largest deteriorating Rate first). The heuristic is proved by -approximation where is the minimum deteriorating rate. We further show that this ratio is tight when and 4. [Copyright &y& Elsevier]

Abstract: Designing truthful mechanisms for scheduling on related machines is a very important problem in single-parameter mechanism design. We consider the covering objective, that is we are interested in maximizing the minimum completion time of a machine. This problem falls into the class of problems where the optimal allocation can be truthfully implemented. A major open issue for this class is whether truthfulness affects the polynomial-time implementation. We provide the first constant factor approximation for deterministic truthful mechanisms. In particular we come up with an approximation guarantee of , significantly improving on the previous upper bound of . [Copyright &y& Elsevier]

Abstract: We study the approximation of the least core value and the least core of supermodular cost cooperative games. We provide a framework for approximation based on oracles that approximately determine maximally violated constraints. This framework yields a 3-approximation algorithm for computing the least core value of supermodular cost cooperative games, and a polynomial-time algorithm for computing a cost allocation in the 2-approximate least core of these games. This approximation framework extends naturally to submodular profit cooperative games. For scheduling games, a special class of supermodular cost cooperative games, we give a fully polynomial-time approximation scheme for computing the least core value. For matroid profit games, a special class of submodular profit cooperative games, we give exact polynomial-time algorithms for computing the least core value as well as a least core cost allocation. [Copyright &y& Elsevier]

Abstract: We consider the problem of releasing multiple types of jobs to a facility over a fixed period. In the problem, each type of job has its own demand for the period and the daily capacity of the facility can fluctuate. The variability of each type is defined as the total absolute deviation between the number of jobs of the corresponding type released on consecutive days. The objective is to minimize the total variability over all types. We show that the problem is strongly NP-hard. In addition, we develop an approximation algorithm and analyze its approximability according to the level of fluctuation of the daily capacity. [Copyright &y& Elsevier]

Abstract: In the field of robust optimization, the goal is to provide solutions to combinatorial problems that hedge against variations of the numerical parameters. This constitutes an effort to design algorithms that are applicable in the presence of uncertainty in the definition of the instance. We study the single machine scheduling problem with the objective of minimizing the weighted sum of completion times. We model uncertainty by replacing the vector of numerical values in the description of the instance by a set of possible vectors, called scenarios. The goal is to find a schedule of minimum value in the worst-case scenario. We first show that the general problem cannot be approximated within for any , unless NP has quasi-polynomial algorithms. We then study more tractable special cases and obtain a linear program (LP)-based -approximation algorithm for the unweighted case. We show that our analysis is tight by providing a matching lower bound on the integrality gap of the LP. Moreover, we prove that the unweighted version is NP-hard to approximate within a factor less than . We conclude by presenting a polynomial-time algorithm based on dynamic programming for the case when the number of scenarios and the values of the instance are bounded by some constant. [Copyright &y& Elsevier]