Two-agent scheduling problems under rejection budget constraints

We consider several serial batch scheduling problems with rejection. Each job is either processed on a single serial batching machine or rejected by paying a penalty. We analyze two models with rejection. The first model is to minimize the sum of the scheduling cost of the accepted jobs and the total penalty of the rejected jobs, where the scheduling costs are the total completion time, the makespan, the maximum lateness and the weighted number of tardy jobs, respectively. For the former two problems, we propose two polynomial time algorithms to solve them. For the last two problems, we derive efficient dynamic programming algorithms. The second model is to minimize the makespan, given an upper bound on the total rejection cost, we present a fully polynomial time approximation scheme.

This paper integrates the two–agent scheduling problem and the order acceptance and scheduling problem, to form a single problem for further investigation. The idea originates from real life situations in which manufacturers deal with different customers, each having different requests. It is, therefore, assumed in the new problem that two customer (agent) types exist while each has their specific penalty functions. The penalty function of the first agent is the total lateness while that of the second is the number of tardy orders. The objective is maximising the total revenue of accepted orders by bounding each agent's penalty function. For this problem, a pseudo–polynomial dynamic programming algorithm is developed. It was shown that the algorithm is capable of optimally solving all the problem instances up to 50 orders in size. The algorithm is found to be capable of solving 87.15% of the instances with 90 orders.

Scheduling with controllable release dates and processing times: Total completion time minimization

The paper deals with some single-machine scheduling problems with setup time considerations where the processing time of a job is given as a function of its starting times and position in a sequence. The setup times are proportional to the length of the already processed jobs, i.e., the setup times are past-sequence-dependent (p-s-d). We consider the following objective functions: the makespan, the total completion time, the sum of the δth (\( \delta \geqslant 0 \)) power of job completion times, the total weighted completion time, the maximum lateness and the number of tardy jobs. We show that the makespan minimization problem, the total completion time minimization problem, and the sum of the δth power of job completion times minimization problem can be solved in polynomial time, respectively. We also show that the total weighted completion time minimization problem, the maximum lateness minimization problem and the number of tardy jobs minimization problem can be solved in polynomial time under certain conditions.

This paper deals with a single machine scheduling problem with general past-sequence-dependent (psd) setup time and log-linear learning in which the setup times and learning effects are job-dependent. The setup times are unique functions of the length of already processed jobs, and the learning effects show that processing times are unique decreasing functions of job positions. The goal is to find the optimal sequences that minimise objective functions such as the makespan, total completion time, total lateness, total waiting cost, total waiting time, total absolute differences in completion times, and the sum of earliness, tardiness and common due date penalty. Special cases of the resulting problems are solvable in polynomial time; however, the general problems are difficult to solve. We propose branch-and-bound (B&B) methods to derive the optimal sequences for such problems. Computational results show that the proposed methods can solve relatively large problem instances in reasonable amounts of time.

In this paper, we develop branch-and-bound algorithms for several hard, two-agent scheduling problems, i.e., problems in which each agent has an objective function which depends on the completion times of its jobs only. Our bounding approach is based on the fact that, for all problems considered, the Lagrangian dual gives a good bound and can be solved exactly in strongly polynomial time. The problems addressed here consist in minimizing the total weighted completion time of the jobs of agent A, subject to a bound on the cost function of agent B, which may be: (i) total weighted completion time, (ii) maximum lateness, (iii) maximum completion time. An extensive computational experience shows the effectiveness of the approach.

Single-machine scheduling problems with deteriorating jobs and learning effects

This paper delves into a two-agent scheduling problem in which two agents are competing for a single resource. Each agent has a set of jobs to be processed by a single machine. The processing time, release time, weight, and the due dates of each job are known in advance. Both agents have their objectives, which are conflicting in nature. The first agent tries to minimize the total completion time, while the second agent tries to minimize the number of tardy jobs. The two agents’ scheduling problem, an NP-hard problem, has a wide variety of applications ranging from the manufacturing industry to the cloud computing service provider. Due to the wide applicability, each variation of the problem requires a different algorithm, adapted according to the user’s requirements. This paper provides mathematical models, heuristic algorithms, and two nature-based metaheuristic algorithms to solve the problem. The algorithm’s performance was gauged against the optimal solution obtained from the AMPL-CPLEX solver for both solution quality and computational time. The outlined metaheuristics produce a solution that is comparable with a short computational time. The proposed metaheuristics even have a better solution than the CPLEX solver for medium-size problems, whereas the computation times are much less than the CPLEX solvers.

We study a set of single-machine two-agent scheduling problems where the performance measure of the first agent, , is the weighted number of jobs completed exactly at the due date, i.e. completed in a just-in-time mode. The performance measure of the second agent, , is either the makespan, the total completion times or the weighted number of jobs completed exactly at the due date. For each combination of performance measures of the two agents, we study four different variations of the problem. We show that all four-problem variations are strongly -hard for when the performance measure of the second agent is either the makespan or the total completion time, even if all of the first agent’s weights are equal. We also study the special case of these problems where the job processing times of the second agent are all equal. For this special case, we prove that three variations of this problem are ordinary -hard with respect to the instance size, while all four problem variations are polynomial solvable with respect to the number of jobs. For the problem where the performance measure of both agents is the weighted number of jobs completed at the due date, we show that one problem variation is solvable in polynomial time, while all other three variations are ordinary -hard.

Single-machine scheduling problems with past-sequence-dependent delivery times

Recently, learning scheduling problems have received increasing attention. However, the majority of the research assume that the actual job processing time is a function of its position. This paper deals with the single-machine scheduling problem with a sum-of-processing-time-based learning effect. By the effect of sum-of-processing-time-based learning, we mean that the processing time of a job is defined by total normal processing time of jobs in front of it in the sequence. We show that the single-machine makespan problem remains polynomially solvable under the proposed model. We show that the total completion time minimization problem for a≥1 remains polynomially solvable under the proposed model. For the case of 0<a<1, we show that an optimal schedule of the total completion time minimization problem is V-shaped with respect to normal job processing times.

This work is a study on scheduling problem with rejection on a set of multi-machine in a flow-shop scheduling system. This paper will attempt to indicate development of a multi-machine flow-shop scheduling model considering rejection (this problem is NP-hard due to the NP-hardness of the same problem variation on a two-machine). We analyse the quality of a solution with two criteria: one is the make span and the one is the total rejection cost. The aim of this study is to present an approximation algorithm and three heuristic algorithms and a genetic algorithm (GA) and successfully applied to Multi-machine flow-shop scheduling model considering rejection to minimise the make span plus total rejection cost. Several tests problems were carried out to assess the performance of the proposed algorithms. We can conclude here that the GA is the most functional algorithm, followed by the approximation algorithm.

This paper considers the combination of the general sum-of-processing-time effect and position-dependent effect on a single machine. The actual processing time of a job is defined by functions of the sum of the normal processing times of the jobs processed and its position and control parameter in the sequence. We consider two monotonic effect functions: the nondecreasing function and the nonincreasing function. Our focus is the following objective functions, including the makespan, the sum of the completion time, the sum of the weighted completion time, and the maximum lateness. For the nonincreasing effect function, polynomial algorithm is presented for the makespan problem and the sum of completion time problem, respectively. The latter two objective functions can also be solved in polynomial time if the weight or due date and the normal processing time satisfy some agreeable relations. For the nondecreasing effect function, assume that the given parameter is zero. We also show that the makespan problem can remain polynomially solvable. For the sum of the total completion time problem and a 1 is the deteriorating rate of the jobs, there exists an optimal solution for a 1 ≥ M ; a V-shaped property with respect to the normal processing times is obtained for 0 < a 1 ≤ 1 . Finally, we show that the sum of the weighted completion problem and the maximum lateness problem have polynomial-time solutions for a 1 > M under some agreeable conditions, respectively.

We consider a single-machine scheduling problem. Given some continuous, nondecreasing cost function, we aim to compute a schedule minimizing the weighted total cost, where the cost of each job is determined by the cost function value at its completion time. This problem is closely related to scheduling a single machine with nonuniform processing speed. We show that for piecewise linear cost functions it is strongly NP-hard. The main contribution of this article is a tight analysis of the approximation guarantee of Smith’s rule under any convex or concave cost function. More specifically, for these wide classes of cost functions we reduce the task of determining a worst-case problem instance to a continuous optimization problem, which can be solved by standard algebraic or numerical methods. For polynomial cost functions with positive coefficients, it turns out that the tight approximation ratio can be calculated as the root of a univariate polynomial. We show that this approximation ratio is asymptotically equal to k ( k − 1)/( k + 1) , denoting by k the degree of the cost function. To overcome unrealistic worst-case instances, we also give tight bounds for the case of integral processing times that are parameterized by the maximum and total processing time.

In this paper, we consider a single machine scheduling problem with release dates. The objective is to minimize the total completion time. This problem is know to be strongly NP-hard. We propose two new lower bounds that can be computed in O(n <sup xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">2</sup> ) and in O(n log n) time respectively. We also propose some dominance properties. A branch-and-bound algorithm in which the lower bounds and the dominance properties are incorporated is proposed and tested on a large set of instances