Scheduling with Multitasking and Outsourcing

Abstract

In the presence of multitasking, a worker has to concurrently handle interruptions from the waiting jobs and routine jobs while processing a primary job. For over a decade, various studies in this research direction have been conducted aiming to figure out how jobs are scheduled so as to reduce the effect due to multitasking. In this paper, two late-job problems in line with the classical late-job problems are tackled. In contrast to the classical setting in which all jobs must be completed, we suggest the idea of outsourcing. Some jobs are outsourced. Thus, the worker only processes the on-time jobs and handles the interruptions from the waiting jobs. Each outsourced job is assigned to a single freelancer to ensure that all jobs are completed on-time. The overhead is the charges to the freelancers, i.e., the total outsourcing cost. If the service charges of all the jobs are the same, the late-job problem is called the total number of outsourcing jobs (TNOJ) problem, which is in-line with the classical total number of late-job problems. If the service charges are different, the late-job problem is called the total weighted number of outsourcing jobs (TWNOJ) problem, which is in-line with the classical total weighted number of late-job problems. For general settings, it is proved that the TNOJ problem is NP-hard and the TWNOJ problem is strongly NP-hard. If the interruption of a waiting job is proportional to its remaining processing time, the TNOJ problem can be solved in $\mathcal{O}(nlog(n\left)P\right)$-time and the TWNOJ problem can be solved in $\mathcal{O}\left(n{P}^2\right)$-time, where n is the number of jobs and P denotes the sum of their processing times.

1. Introduction

Integrating human factors in scheduling problems has been studied for many decades [1]. Two notable factors are the learning effect [2,3,4] and aging (equi. deterioration) effect [5]. In the last decade, multitasking has attracted scheduling theorists to incorporate this human factor in scheduling problems. Multitasking refers to a human behavior in which a person handles multiple tasks in a period of time [6,7]. While some studies [8,9] have found that multitasking can help to improve the skills of a worker in handling multiple tasks, the actual benefit of multitasking has yet to be discovered. Normally, multitasking is not recommended [6,7] as multitasking could cause learning problem [10], attention deficit trait (ADT) [11] and stress [12,13] of a person; it can also decrease a person’s productivity [14,15,16,17]. Nevertheless, mental response delay is inevitable in task switching [18] and humans have difficulties in switching between functional brain networks [19].

In reality, however, multitasking is necessary in some works like air traffic control (ATC) and flight control [20]. An air traffic controller needs to schedule multiple flights’ taking off and landing. A pilot needs to control a flight as well as communicate with the air traffic controllers (sometimes together with pilots from other flights) for taking off or landing. In a weekend evening, the kitchen team of a restaurant has to serve orders concurrently and at the same time handle interruptions from some guests’s special requests, such as re-heat a soup and re-do a steak. In a semester, a professor needs to concurrently conduct multiple research projects, supervise multiple research students, prepare teaching materials and respond to student enquires in weekly consultations.

Eventually, this led Hall, Leung and Li [21,22] to incorporate interruption function and switching cost in the scheduling models to capture this multitasking behavior. Thus, the effect of multitasking from the perspective of operations scheduling was delineated.

1.1. Interruption-Based Multitasking Scheduling Models

Take a set of jobs $\{J_1,\cdots ,J_n\}$. Let $\mathcal{S}=\{J_{{\mathit{\pi }}_1},\cdots ,J_{{\mathit{\pi }}_n}\}$ be a schedule. With multitasking, the owners of the jobs $J_{{\mathit{\pi }}_{i+1}},\cdots ,J_{{\mathit{\pi }}_n}$ could interrupt the worker while he is processing $J_{{\mathit{\pi }}_i}$. The worker will have to switch to each interrupting job and handle part of it. The amount of a job $J_{{\mathit{\pi }}_j}$ to be processed in its $t^{th}$ interruption is defined by the interruption function $g_{{\mathit{\pi }}_j}\left(t\right)$, for $j=i+1,\cdots ,n$. The amount of time switching from $J_{{\mathit{\pi }}_i}$ to $J_{{\mathit{\pi }}_j}$ is defined by the switching cost function $f_{{\mathit{\pi }}_i{\mathit{\pi }}_j}$.

1.1.1. Model

Using the terminologies in [21,22], $J_{{\mathit{\pi }}_i}$ is called the primary job and $J_{{\mathit{\pi }}_{i+1}},\cdots ,J_{{\mathit{\pi }}_n}$ are called the waiting jobs when $J_{{\mathit{\pi }}_i}$ is being processed. Let $p_{{\mathit{\pi }}_i}\left(k\right)$ be the remaining processing time of $J_{{\mathit{\pi }}_i}$ after $J_{{\mathit{\pi }}_1}$ to $J_{{\mathit{\pi }}_{i-1}}$ have been completed. We can get that

$$p_{{\mathit{\pi }}_i}\left(k\right)=\left\{\begin{array}{cc}{p}_{{\mathit{\pi }}_i}(k-1)-g_{{\mathit{\pi }}_i}\left(k\right)\hfill & \mathrm{if} 1\le k\le i-1,\hfill \\ 0\hfill & \mathrm{if} k\ge i\hfill \end{array}\right.$$

(1)

and $p_{{\mathit{\pi }}_i}\left(0\right)=p_{{\mathit{\pi }}_i}$ for $i=1,2,\cdots ,n$. Thus the completion time of $J_{{\mathit{\pi }}_i}$ is given by

$$c_{{\mathit{\pi }}_i}\left(S\right)=c_{{\mathit{\pi }}_{i-1}}\left(\mathcal{S}\right)+p_{{\mathit{\pi }}_i}(i-1)+\sum _{j=i+1}^n\left(g_{{\mathit{\pi }}_j}\left(i\right)+f_{{\mathit{\pi }}_i{\mathit{\pi }}_j}\right)$$

if $i=1,\cdots ,n-1$ and $c_{{\mathit{\pi }}_i}\left(S\right)=c_{{\mathit{\pi }}_{n-1}}\left(\mathcal{S}\right)+p_{{\mathit{\pi }}_n}(n-1)$ if $i=n$. Here $c_{{\mathit{\pi }}_0}=0$.

1.1.2. Objectives

With the new problem setting and $f_{ij}$ as a constant, Hall, Leung and Li [21,22] developed polynomial-time algorithms for solving the total weighted completion time (TWCT) problem and the maximum lateness (ML) problem. While they have further shown that the TNLJ (resp. the TWNLJ) problem is NP-hard (resp. strongly NP-hard), a polynomial-time (resp. pseudo-polynomial-time) algorithm is developed for the case that the interruption function is defined as $g_i\left(p_i^{\prime }\right)=D{p}_i^{\prime }$ ($0<D<1$), where $p_i^{\prime }$ is the remaining processing time. Empirical analyses on the effect of multitasking on operations scheduling were then conducted.

1.1.3. Real Case Study I: Research Projects’ Supervision

As a college professor, we need to supervise a number of research students including master and doctoral students. Suppose that we are going to retire in five years, i.e., 60 months (resp. we are not going to recruit new students in the coming five years), and four current students expected graduations are in one, two, three and five years. One major problem is that the students are weak in English and they are unable to write any papers in English. So, as the supervisor, we need to complete conference and journal papers for the students to fulfill their graduation criteria.

So, the professor needs to estimate the processing times for conducting the remaining projects and writing the papers, i.e., $p_1,p_2,p_3,p_4$. Next, the professor needs to schedule the times for meetings and the time spent on each meeting. The time spent on each meeting is clearly the interruption time. (Even more challenging, the meeting times are constraints due to the availabilities of the student.) With their due dates in term of months, their due dates (equi. graduation dates) are respectively $d_1=12$, $d_2=24$, $d_3=36$ and $d_4=60$. With all of this information, the supervisor can schedule to optimize the total number of on-time graduations.

For those students who are concerned about their thesis (resp. dissertation) quality, the above setting is not applicable as the students are willing to extend their dates of graduations. However, like some EMBA students, they pay for their theses and the certifications. They are much more concerned about their dates of graduation rather than what they have contributed (resp. done). Our settings indicate what the reality is and are the motivations for why a supervisor has to multitask.

1.1.4. Real Case Study II: Startup Intelligent Service Firm

For an intelligent service startup firm, it needs to deliver intelligent service by a due date as requested by the investors. If the startup cannot commit, it might not get further funding from the investors. Usually, the system supporting the intelligent service consists of multiple sub-systems. Without a time limit, the startup can develop all sub-systems in-house. With a due date and limited workforce, the startup has to outsource some sub-systems development to freelance programmers. If the development costs of different sub-systems are different, this outsourcing problem is essentially the same as our TWNOJ problem.

1.2. Subsequent Works Along Interruption-Based Models

Many related works have been conducted in the last decade. For clarity, the settings for the multitasking scheduling problems are depicted in Table 1. Considering that $f_{ij}$ is a constant and $g_i\left(p_i^{\prime }\right)=D{p}_i^{\prime }$, Sum and Ho [23] statistically analyzed the effect of multitasking on the expected performance of a worker. As anticipated, the performance (say TWCT) would drastically degrade if the number of jobs is large. If the switching cost is symmetric (i.e., $f_{ij}=f_{ji}$) instead of a constant value, Sum and Ho in [24] have shown that the polynomial-time algorithms developed by Hall, Leung and Li [22] for the TWCT and ML problems can be equally applied to solve the problems with symmetric switching cost. Sum and Ho in [24] have further introduced two slightly different late-job problems in which the owners of the late-jobs are not allowed to interrupt the worker. The purpose is to let the worker finish more on-time jobs.

Table 1. Settings for the multitasking scheduling problems.

Attribute	Settings
No. of agents	One, multiple.
No. of machines	One, multiple.
Interruption	Constant $\kappa$, proportionate $D{p}_i^{\prime }$, arbitrary.
Switching cost	Symmetric $f_{ij}=f_{ji}$, asymmetric $f_{ij}\ne f_{ji}$, $f_{ij}={\kappa }_1{f}_i+{\kappa }_2{f}_j$.
Rate-Modifying	Time-dependent, position-dependent (learning and deterioration).
Late-jobs	Processed last in the schedule, late-jobs discarded.

Here, D, $\kappa$, ${\kappa }_1$ and ${\kappa }_2$ are constants.

The multitasking scheduling problems with asymmetric switching costs are investigated [25] and it was shown that the makespan problem is already $\mathcal{NP}$-hard but some special cases are polynomial-time solvable. If (i) $g_i\left(p_i^{\prime }\right)=\overline{g}$ or $g_i\left(p^{\prime }\right)=D{p}_i^{\prime }$ and/or (ii) the switching cost is given by $f_{ij}={\kappa }_1{f}_i+{\kappa }_2{f}_j$ (${\kappa }_1$ and ${\kappa }_2$ are constants; $f_i$ is a job-dependent factor), the makespan problem, the total completion time problem and the common due date assignment problem are polynomial-time solvable. By formulating a due date assignment problem as a linear assignment problem, Liu et al. showed that the problem is polynomial-time solvable [26]. Furthermore, if $g_i\left(p_i^{\prime }\right)=D{p}^{\prime }$, the problem is $\mathcal{O}(nlog(n\left)\right)$-time solvable. Various multitasking scheduling problems with position-dependent processing rates were studied in [27,28,29]. If the interruption function $g_i\left(p_i^{\prime }\right)=D{p}^{\prime }$, the makespan problem, the total completion time problem, the maximum lateness problem and the common due date assignment problem are polynomial-time solvable.

1.3. Other Multitasking Scheduling Models

Owing to the reduced effects due to the following, Hall, Leung and Li in [30] introduced two multitasking scheduling models. The first one is due to the idea of alternate period processing. Two time spans ${\tau }_o$ and ${\tau }_e$ are respectively assigned as the odd period working time and the even period working time. The jobs assigned on the odd periods must be different from the jobs assigned on the even periods. The worker is then required to switch to the other job after they have been working on a job for a period of time. Algorithms were developed for the related scheduling problems. The other multitasking scheduling model deals with the problem that the worker has to handle routine job interruptions while the worker is engaging in a primary job.

As a result, multitasking scheduling problems with progress control and lag-behind penalty [31], machine-dependent slack due-window assignment [32], multi-agent setting [33,34] and multi-agent-multi-machine setting [35] were introduced. Liu, Chen & Tian [36] investigated the multitasking scheduling problems with job switching costs incurred and the jobs to be completed by two agents. Wu et al. [37] investigated the multitasking scheduling problems, in which two agents share a single machine. With due date assignment, Yang et al. [38] investigated the problem setting with two agents. Fu, Hua & Zhao [39] investigated the setting on parallel machines with shared processing, i.e., each machine needs to share processing time to handle both multitasking jobs and routine jobs.

1.4. Interruption-Based Late-Job Problems Without Outsourcing

In the Hall–Leung–Li late-job problem setting [22], the in-house worker has to complete all the jobs and so he needs to handle the interruptions from the owners of the waiting jobs. Suppose we have five jobs to be processed. Their processing times and due dates are given below. As all waiting jobs can interrupt the primary job, only one job (either $J_2$ or $J_4$) can be on-time and four other jobs are late.

$${\mathcal{S}}^{\prime }=\{J_2,J_1,J_3,J_4,J_5\}\mathrm{and}{\mathcal{S}}^{″}=\{J_4,J_1,J_2,J_3,J_5\}.$$

For ${\mathcal{S}}^{\prime }$, the completion time of the on-time job $J_2$ is $c_2=14$. For ${\mathcal{S}}^{″}$, the completion time of the on-time job $J_4$ is that $c_4=10$.

1.5. Interruption-Based Late-Job Problems with Outsourcing (Our Problems)

If there is no late penalty incurred, it is fine to schedule the jobs like ${\mathcal{S}}^{\prime }$ or ${\mathcal{S}}^{″}$. In reality, however, a late penalty could be incurred and it could be unaffordable. Thus, it is not possible to let the in-house worker finish all the jobs. Some of them have to be outsourced. If an outsourced job is assigned to a single freelance worker, the in-house worker can finish more jobs on-time. Furthermore, all jobs will be completed on-time. For the above example, one possible schedule is to partition the jobs in two sets.

$$\mathcal{S}=\{J_5,J_2\}\mathrm{and}\mathcal{O}=\{J_1,J_3,J_4\}.$$

The jobs in $\mathcal{S}$ are assigned to the in-house worker. $J_5$ has to be processed before $J_2$. The jobs in $\mathcal{O}$ are outsourced to three freelance workers. The overhead is simply the service charges for the freelance workers.

1.5.1. Objectives (Total Outsourcing Costs)

Here, we consider two objectives resembling the classical total late-jobs and total weighted late-jobs. With outsourcing, all the jobs must be on-time. In other words, no job is late. Therefore, we use $U_i$ to denote if a job $J_i$ is outsourced.

$$U_i=\left\{\begin{array}{cc}1\hfill & \mathrm{if} J_i \mathrm{is} \mathrm{outsourced},\hfill \\ 0\hfill & \mathrm{if} J_i \mathrm{is} \mathrm{on-time}.\hfill \end{array}\right.$$

First, the service charges of all the jobs are equal. The objective to be minimized is the ‘total number of outsourced jobs (TNOJ)’, i.e., ${\sum }_i{U}_i$. It is in-line with the classical TNLJ problem. We denote this problem as $1|mt, os|{\sum }_i{U}_i$, where the shorthand ‘$mt$’ stands for multitasking, ‘$os$’ stands for outsourcing and

Second, each job has its own service charge $w_i$ for $i=1,\cdots ,n$. The objective to be minimized is the ‘total weighted number of outsourced jobs (TWNOJ)’, i.e., ${\sum }_i{w}_i{U}_i$. It is in-line with classical TWNLJ problem. We denote this problem as $1mt, os|{\sum }_i{w}_i{U}_i$, where $w_i$ is the service charge to be paid to the freelance worker.

As suggested by a reviewer, either objective can simply be called the total outsourcing cost. The objective of our problems is to find schedules that can minimize their respective outsourcing costs.

1.5.2. Assumptions

To optimize the efficiency of a worker (resp. a team) to complete the jobs in the presence of multitasking, scheduling seems to be a recommended method [20,40,41]. Without proper scheduling, the effect of multitasking could be severe [6,42,43]. For both the TNOJ and TWNOJ problems, it is assumed that the information of all n jobs is available at time $t=0$. The jobs do not arrive dynamically. Thus, we have made the following assumptions for our problems: (i) the jobs’ processing times $p_1,\cdots ,p_n$, (ii) their due dates $d_1,\cdots ,d_n$, (iii) their outsourcing costs $w_1,\cdots ,w_n$ and (iv) their interruption models $g_i\left(k\right)$ are available at time $t=0$; (v) the actual processing time of a job ${\tilde{p}}_i$ is identical to the information $p_i$ available at time $t=0$, i.e., ${\tilde{p}}_i=p_i$ for $i=1,\cdots ,n$; and (vi) there is only one working team processing the on-time jobs.

For those problems in which the jobs arrive dynamically, dynamic scheduling algorithms as presented in [44,45] or AI-based scheduling algorithms [46,47] could be applied. If ${\tilde{p}}_i\ne p_i$, sensitivity analysis advocated in [48,49] is needed to analyze the robustness and the effect of the proposed scheduling algorithms due to uncertainty.

1.6. Contributions and Organization of the Paper

In this paper, four major contributions are presented. It will be shown in Section 2 that (i) the problem $1|mt, os|{\sum }_i{U}_i$ is NP-hard and (ii) the problem $1|mt, os|{\sum }_i{w}_i{U}_i$ is strongly NP-hard. For the special case that $g_i\left(p_i^{\prime }\right)=D{p}_i^{\prime }$, we present in Section 3 that (iii) $1|mt, os|{\sum }_i{U}_i$ can be solved in $\mathcal{O}(nlog(n\left)P\right)$-time and (iv) $1|mt, os|{\sum }_i{w}_i{U}_i$ can be solved in $\mathcal{O}(n^{2}log\left(n\right)P)$-time. Finally, the conclusions of the paper follow in Section 4.

2. Complexity Analysis

To analyze the complexities of the problems $1|mt, os|{\sum }_i{U}_i$ and $1|mt, os|{\sum }_i{w}_i{U}_i$, we need the following lemma regarding the due dates of the jobs in an optimal schedule for the in-house worker.

Lemma 1.

For the late-job problems, there exists an optimal schedule $\{\mathcal{S},\mathcal{O}\}$, in which $\mathcal{S}$ is the set of on-time jobs assigned to the in-house worker and the jobs in $\mathcal{O}$ are outsourced. Moreover, the jobs in $\mathcal{S}$ are scheduled in EDD order with no inserted idle time.

Proof. 

As $U_i$ is a nondecreasing function of $c_i$ for all i, there exists an optimal schedule with no inserted idle time. Let $\mathcal{S}$ be an optimal schedule with m on-time jobs.

$$\mathcal{S}=\{J_{{\mathit{\pi }}_1},\cdots ,J_{{\mathit{\pi }}_r},J_{{\mathit{\pi }}_s},\cdots ,J_{{\mathit{\pi }}_m}\}.$$

If $d_{{\mathit{\pi }}_s}\le d_{{\mathit{\pi }}_r}$, we can construct a new schedule ${\mathcal{S}}^{\prime }$ by interchanging $J_{{\mathit{\pi }}_r}$ and $J_{{\mathit{\pi }}_s}$, i.e.,

$${\mathcal{S}}^{\prime }=\{J_{{\mathit{\pi }}_1},\cdots ,J_{{\mathit{\pi }}_s},J_{{\mathit{\pi }}_r},\cdots ,J_{{\mathit{\pi }}_m}\}.$$

Since $c_{{\mathit{\pi }}_s}\left({\mathcal{S}}^{\prime }\right)<c_{{\mathit{\pi }}_s}\left(\mathcal{S}\right)$ and $c_{{\mathit{\pi }}_s}\left(\mathcal{S}\right)\le d_{{\mathit{\pi }}_s}$, $J_{{\mathit{\pi }}_s}$ is on-time. On the other hand, the total amount of interruptions from $J_{{\mathit{\pi }}_{s+1}},\cdots ,J_{{\mathit{\pi }}_m}$ is the same. $c_{{\mathit{\pi }}_r}\left({\mathcal{S}}^{\prime }\right)=c_{{\mathit{\pi }}_s}\left(\mathcal{S}\right)\le d_{{\mathit{\pi }}_s}\le d_{{\mathit{\pi }}_r}$. So, $J_{{\mathit{\pi }}_r}$ is on-time. ${\mathcal{S}}^{\prime }$ is also an optimal schedule. By repeatedly applying pairwise interchange, a schedule consisting of all on-time jobs sequenced in EDD order can be obtained. The proof is completed.    □

Without loss of generality, it is assumed that the processing time of a job is always smaller than its due date, i.e., $p_i<d_i$ for $i=1,\cdots ,n$. Let $w_1,\cdots ,w_n$ be the service charges for the jobs $J_1,\cdots ,J_n$. If $w_i=\overline{w}$ for all $i=1,\cdots ,n$, the problem is denoted as $1|mt, os|{\sum }_i{U}_i$. If $w_1,\cdots ,w_n$ are not all equal, the problem is denoted as $1|mt, os|{\sum }_i{w}_i{U}_i$.

2.1. Total Number of Outsourced Jobs (TNOJ)

If there is no multitasking and the late-jobs are outsourced, the problem $1\left|os\right|{\sum }_i{U}_i$ is essentially the same as the classical TNLJ problem. Thus, it can be solved using the Moore algorithm in $\mathcal{O}(nlog(n\left)\right)$-time. In the presence of multitasking, the problem $1|mt,os|{\sum }_i{U}_i$ is NP-hard.

Theorem 1.

The problem $1|mt, os|{\sum }_i{U}_i$ is NP-hard.

Proof. 

Without loss of generality, we assume that there is no switching cost. We prove the theorem by reduction from the Equal Cardinality Partition problem which is known to be NP-hard [50]. Given a set $A=\{1,2,\cdots ,2q\}$ and a size $a_i$ for each element $i\in A$, does there exist $A^{\prime }\subset A$ such that $|A^{\prime }|=q$ and ${\sum }_{i\in A^{\prime }}{a}_i={\sum }_{i\in A\setminus A^{\prime }}{a}_i$? The key to completing this proof is the definition of the interruption function $g_i\left(p_i^{\prime }\right)$.

Given an arbitrary instance of Equal Cardinality Partition, we construct an instance of the problem $1|mt, os|{\sum }_i{U}_i$ with $n=3q$ jobs, $\mathcal{J}=\{J_1,\cdots ,J_{2q},J_{2q+1},\cdots ,J_{3q}\}$. We call the first $2q$ jobs $J_1,\cdots ,J_{2q}$ the element jobs. The last q jobs $J_{2q+1},\cdots ,J_{3q}$ are called the unit-time jobs. Furthermore, we set that ${\sum }_{i\in A}{a}_i=2B$ and N is a positive number such that $a_i-(2q-1)(B-a_i)/\left(qN\right)>0$ for all i. The processing times are defined as follows:

$$p_i=\left\{\begin{array}{cc}{a}_i+B\hfill & \mathrm{for} i=1,2,\cdots ,2q,\hfill \\ 1\hfill & \mathrm{for} i=2q+1,2q+2,\cdots ,3q.\hfill \end{array}\right.$$

(2)

Their due dates are defined as follows:

$$d_i=\left\{\begin{array}{cc}q+(q+1)B\hfill & \mathrm{for} i=1,2,\cdots ,2q,\hfill \\ q+{\displaystyle \frac{(q-1)B}{N}}\hfill & \mathrm{for} i=2q+1,2q+2,\cdots ,3q,\hfill \end{array}\right.$$

(3)

For the interruption, only the element jobs are allowed to interrupt but not the unit-time jobs, i.e.,

$$g_i\left(p_i^{\prime }\right)=\left\{\begin{array}{cc}{\displaystyle \frac{B-a_i}{qN}}\hfill & \mathrm{for} i=1,2,\cdots ,2q,\hfill \\ 0\hfill & \mathrm{for} i=2q+1,2q+2,\cdots ,3q.\hfill \end{array}\right.$$

(4)

The threshold for TNOJ y is q, i.e., ${\sum }_{i\in \mathcal{S}}{U}_i\le y=q$.

Clearly, the above construction can be done in polynomial time. We will show that there exists a solution to the constructed instance if and only if there exists a solution to the given instance of the Equal Cardinality Problem.

• (⇒) Suppose there exists $A^{\prime }\subset A$ such that $|A^{\prime }|=q$ and ${\sum }_{i\in A^{\prime }}{a}_i=B$. We can construct a schedule $\mathcal{S}$ simply as follows:

  $$\mathcal{S}=\{J_{2q+1},\cdots ,J_{3q},J_{{\mathit{\pi }}_1},\cdots ,J_{{\mathit{\pi }}_q}\},$$

  where ${\mathit{\pi }}_1,{\mathit{\pi }}_2,\cdots ,{\mathit{\pi }}_q\in A^{\prime }$.

As only the element jobs will interrupt all the unit-time jobs, the completion time of $J_{3q}$ is $q+q{\sum }_{i\in A^{\prime }}(B-a_i)/qN$, which is equal to $q+(q-1)B/N$, and the completion time of $J_{{\mathit{\pi }}_q}$ is $q+{\sum }_{i\in A^{\prime }}(a_i+B)$, which is equal to $q+(q+1)B$; all jobs in $\mathcal{S}$ are on-time and ${\sum }_{j=1}^n{U}_i\left(\mathcal{S}\right)=y$.

• (⇐) Let $\mathcal{S}$ be an optimal schedule. Hence, $\left|\mathcal{S}\right|=2q$. By Lemma 1, the set of unit-time jobs in $\mathcal{S}$ must be scheduled before the set of element jobs. Moreover, $\mathcal{S}$ must have exactly q unit-time jobs and q element jobs on-time. As $B>q/2$, to process an additional element job on-time will lead to discarding half of the unit-time jobs. Therefore, $\mathcal{S}$ must have exactly q unit-time jobs and followed by q element jobs.

As the completion time of the last unit-time job must be earlier than $q+(q-1)B/N$, we have $q+q{\sum }_{i\in A^{\prime }}{\displaystyle \frac{(B-a_i)}{qN}}\le q+{\displaystyle \frac{(q-1)B}{N}}$, or ${\sum }_{i\in A^{\prime }}{a}_i\ge B$. On the other hand, the completion of the last element job must be earlier than $q+(q+1)B$. So, we get that $q+{\sum }_{i\in A^{\prime }}(a_i+B)\le q+(q+1)B$, or ${\sum }_{i\in A^{\prime }}{a}_i\le B$. Therefore, we can get that ${\sum }_{i\in A^{\prime }}{a}_i=B$.    □

2.2. Total Weighted Number of Outsourced Jobs (TWNOJ)

It is known that the problem $1\left|\right|{\sum }_i{w}_i{U}_i$ is NP-hard [51]. In the presence of multitasking and outsourcing, the problem $1|mt, os|{\sum }_i{w}_i{U}_i$ is strongly NP-hard.

Theorem 2.

The problem $1|mt, os|{\sum }_i{w}_i{U}_i$ is strongly NP-hard.

Proof. 

We prove the theorem by reduction from the Exact Cover by 3-Sets (X3C) problem, which is known to be strongly NP-hard [50]. An X3C instance contains a finite set $\mathcal{X}=\{x_1,\cdots ,x_{3q}\}$, where q is a positive integer, and a collection $\mathcal{C}=\{C_1,\cdots ,C_r\}$ of 3-element subsets of $\mathcal{X}$, where $r\ge q$. The X3C problem is to ask if there exists a $C^{\prime }\subseteq C$ such that every element of $\mathcal{X}$ appears in exactly one member of $C^{\prime }$. In other words, all the members in $C^{\prime }$ are mutually exclusive and the union of all the members in $C^{\prime }$ equals $\mathcal{X}$.

Let $\mathcal{X}=\{1,2,\cdots ,3q\}$ and $C_j=\{x_{j,1},x_{j,2},x_{j,3}\}\subset \mathcal{X}$. Given an arbitrary instance of X3C, the corresponding instance of the problem $1mt, os|\sum w_i{U}_i$ can be constructed. First, we define a set of $(3q+r)$ jobs.

$$\mathcal{J}=\{J_1,J_2,\cdots ,J_{3q},J_{3q+1},\cdots ,J_{3q+r}\}.$$

For the sake of presentation, we call the jobs $J_1$, $J_2$, ⋯, $J_{3q}$ the element jobs referring the elements in X and the jobs $J_{3q+1}$, $J_{3q+2}$, ⋯, $J_{3q+r}$ the member jobs referring the member sets in $\mathcal{C}$.

For each job $J_i\in \mathcal{J}$, its processing time, due date and weight are defined as follows:

$$\begin{array}{ccc}\hfill p_i& =& \left\{\begin{array}{cc}1\hfill & \mathrm{if} i=1,\cdots ,3q.\hfill \\ N+3(q+1)\hfill & \mathrm{if} i=3q+1,\cdots ,3q+r,\hfill \end{array}\right.\hfill \end{array}$$

(5)

$$\begin{array}{ccc}\hfill d_i& =& \left\{\begin{array}{cc}i(q+2)\hfill & \mathrm{if} i=1,\cdots ,3q.\hfill \\ 3q(q+2)+qN\hfill & \mathrm{if} i=3q+1,\cdots ,3q+r,\hfill \end{array}\right.\hfill \end{array}$$

(6)

$$\begin{array}{ccc}\hfill w_i& =& \left\{\begin{array}{cc}M\hfill & \mathrm{if} i=1,\cdots ,3q.\hfill \\ M-x_{i,1}-x_{i,2}-x_{i,3}\hfill & \mathrm{if} i=3q+1,\cdots ,3q+r.\hfill \end{array}\right.\hfill \end{array}$$

(7)

In (5)–(7),

$$N>(q+2),\mathrm{and}M>9q^2.$$

(8)

For the element jobs, there is no interruption, i.e., $g_i=0$ for $i=1,\cdots ,3q$. For the member jobs, their $k^{th}$ interruptions are defined as follows:

$$g_{3q+j}\left(k\right)=\left\{\begin{array}{cc}2\hfill & \mathrm{if} k\in \{x_{j,1},x_{j,2},x_{j,3}\},\hfill \\ 1\hfill & \mathrm{otherwise},\hfill \end{array}\right.$$

(9)

for $j=1,\cdots ,q$. The threshold of TWNOJ y is defined as

$$y=(r-q)M-\left(A-{\displaystyle \frac{3q(3q+1)}{2}}\right),$$

(10)

where $A={\sum }_{C_j\in C}(x_{j,1}+x_{j,2}+x_{j,3})$.

• (⇒) Let ${\mathcal{C}}^{\ast }=\{C_{{\mathit{\pi }}_1},\cdots ,C_{{\mathit{\pi }}_q}\}$ be a subset of $\mathcal{C}$ such that ${\bigcup }_{C_j\in {\mathcal{C}}^{\ast }}{C}_j=\mathcal{X}$ and $C_j\bigcap C_{j^{\prime }}=\varphi$ for $j\ne j^{\prime }$. It is clear that we can construct the schedule $\mathcal{S}$ as follows:

  $$\mathcal{S}=\{J_1,J_2,\cdots ,J_{3q},J_{3q+{\mathit{\pi }}_1},\cdots ,J_{3q+{\mathit{\pi }}_q}\}.$$
  All the jobs are on-time and ${\sum }_{i\in \mathcal{S}}{w}_i{U}_i=(r-q)M-\left(A-\left(3q\right(3q+1\left)\right)/2\right)$.
• (⇐) Let ${\mathcal{S}}^{\prime }$ be a feasible schedule and by Lemma 1, ${\mathcal{S}}^{\prime }$ consists of a set of element jobs scheduled in EDD order and followed by a set of member jobs. All the jobs in ${\mathcal{S}}^{\prime }$ are on-time and ${\sum }_{i\in {\mathcal{S}}^{\prime }}{w}_i{U}_i\le (r-q)M-(A-3q(3q+1)/2)$. Furthermore, ${\mathcal{S}}^{\prime }$ must have exactly $3q$ element jobs and q member jobs. Here, we use the notation ${\mathcal{S}}^{\prime }$ to differentiate it from the schedule $\mathcal{S}$ above.

As the processing time of a member job is larger than $3q$, to process an additional element job on-time will lead to discarding all element jobs. In the end, the TWNOJ value will be larger than threshold. In the reverse case, discarding any number of element jobs again cannot reduce the value of TWNOJ. ${\mathcal{S}}^{\prime }$ must have exactly $3q$ element jobs and q member jobs. For the sake of presentation,

$${\mathcal{S}}^{\prime }=\{J_1,J_2,\cdots ,J_{3q},J_{3q+{\mathit{\pi }}_1^{\prime }},\cdots ,J_{3q+{\mathit{\pi }}_q^{\prime }}\}.$$

We further denote that ${\mathcal{C}}^{\prime }=\{C_{{\mathit{\pi }}_1^{\prime }},\cdots ,C_{{\mathit{\pi }}_q^{\prime }}\}$, to differentiate it from ${\mathcal{C}}^{\ast }$. Its property will be investigated shortly.

As the completion times of the last job is $3q(q+2)+qN$, it is clear that all q member jobs are on-time. For the elements jobs, we have that

$$c_i\le i(q+2)\mathrm{for} i=1,\cdots ,3q.$$

(11)

Now, we are going to figure out under what condition the inequality (11) holds. Let ${\alpha }_1,\cdots ,{\alpha }_{3q}$ be the number of times $1,\cdots ,3q$ appeared in ${\mathcal{C}}^{\prime }=\{C_{{\mathit{\pi }}_1^{\prime }},\cdots ,C_{{\mathit{\pi }}_q^{\prime }}\}$. Clearly,

$$\sum _{k=1}^{3q}{\alpha }_k=3q.$$

(12)

As $c_i=i(q+1)+{\sum }_{k=1}^i{\alpha }_k\le i(q+2)$ for $i=1,\cdots ,3q$, we can get that

$$\sum _{k=1}^i{\alpha }_k\le i\mathrm{for} i=1,\cdots ,3q.$$

(13)

Moreover, the TWNOJ must be smaller than the threshold. We get that

$$\begin{array}{ccc}& & (r-q)M-\left(A-\sum _{C_j\in {\mathcal{C}}^{\prime }}\left(x_{j,1}+x_{j,2}+x_{j,3}\right)\right)\hfill \\ & \le & (r-q)M-\left(A-{\displaystyle \frac{3q(3q+1)}{2}}\right)\hfill \end{array}$$

or equivalently

$$\sum _{k=1}^{3q}k{\alpha }_k\le {\displaystyle \frac{3q(3q+1)}{2}}.$$

(14)

It has been shown in (Online Appendix pp. 5–6, [22]) that ${\alpha }_1=\cdots ={\alpha }_{3q}=1$ is the unique solution for (12)–(14). In other words, the number of times the numbers $1,\cdots ,3q$ appeared in ${\mathcal{C}}^{\prime }=\{C_{{\mathit{\pi }}_i^{\prime }},\cdots ,C_{{\mathit{\pi }}_q^{\prime }}\}$ are all one. $C_{{\mathit{\pi }}_j^{\prime }}\cap C_{{\mathit{\pi }}_{j^{\prime }}^{\prime }}=\varphi$ and ${\cup }_{C_j\in {\mathcal{C}}^{\prime }}=\mathcal{X}$. The X3C problem is solved. The proof is completed.    □

3. Special Case: ${\mathit{g}}_{\mathit{i}}\left({\mathit{p}}_{\mathit{i}}^{\prime }\right)={\mathit{Dp}}_{\mathit{i}}^{\prime }$

Theorems 1 and 2 have shown that job scheduling in the presence of multitasking is generally at least an $\mathit{NP}$-hard problem. For the special case that the interruption of a waiting job is given by $g_i\left(p_i^{\prime }\right)=D{p}_i^{\prime }$ and there is no switching cost, Hall et al. in [22] have shown that the problem is polynomial-time solvable if all the jobs are completed by a single agent.

For the problems to be investigated in this section, the amount of interruption to a waiting job (say $J_i$) $g_i\left(p_i^{\prime }\right)$ is proportional to its remaining processing time $p_i^{\prime }$. Moreover, it is assumed that there is no switching cost and the agent can discard jobs. Let $0<D<1$. $g_i\left(p_i^{\prime }\right)=D{p}_i^{\prime }$ for $i=1,\cdots ,n$, $f_{ij}=0$, where $i\ne j$ and $i,j=1,\cdots ,n$.

3.1. Total Number of Outsourced Jobs

Before describing our algorithm for solving the problem $1|mt, os, g_i\left(p_i^{\prime }\right)=D{p}_i^{\prime }|{\sum }_i{U}_i$, let us review the problem posed by Hall, Leung and Li [22] in which the in-house worker has to process all the jobs.

3.1.1. Hall–Leung–Li TNLJ Algorithm

Let ${\mathcal{J}}_{EDD}=\{J_1,\cdots ,J_n\}$ be a set of jobs with their due dates in EDD order, i.e., $d_1\le d_2\le \cdots \le d_n$. Let ${\mathcal{S}}_T$ be the set of on-time jobs after some jobs have been checked. The set of on-time jobs is set to be the empty set, i.e., ${\mathcal{S}}_T=\left\{\right\}$. We further let ${\mathcal{S}}_T=\{J_{{\mathit{\pi }}_1},\cdots ,J_{{\mathit{\pi }}_r}\}$ be the set of on-time jobs after the jobs $J_1,\cdots ,J_{i-1}$ have been checked.

To determine if $J_i$ has to be appended to ${\mathcal{S}}_T$, we check the condition of whether it is included and its completion time $c_i\le d_i$. If $J_i$ is included, the set of on-time jobs is ${\mathcal{S}}_T\bigcup \left\{J_i\right\}$ and there will be $(r+1)$ on-times jobs. Thus, the completion time $c_i$ is given by

$$c_i=\sum _{j\in {\mathcal{S}}_T\bigcup \left\{J_i\right\}}{p}_j+\left(1-{(1-D)}^{r+1}\right)\sum _{j\notin {\mathcal{S}}_T\bigcup \left\{J_i\right\}}{p}_{{\mathit{\pi }}_j}.$$

Let $P={\sum }_{j=1}^n{p}_j$ be the total processing times. We can equivalently get that

$$c_i=P-{(1-D)}^{r+1}\left(P-\left(p_i+\sum _{j\in {\mathcal{S}}_T}{p}_j\right)\right).$$

If $c_i\le d_i$, ${\mathcal{S}}_T={\mathcal{S}}_T\bigcup \left\{J_i\right\}$ and otherwise ${\mathcal{S}}_T={\mathcal{S}}_T\bigcup \left\{J_i\right\}\setminus \left\{J_{★}\right\}$, where $J_{★}=arg{max}_{j\in {\mathcal{S}}_T\bigcup \left\{J_i\right\}}\left\{p_j\right\}$. Then, we set $i=i+1$ and repeat the steps.

Eventually, an optimal schedule $\mathcal{S}$ can be obtained. Suppose the schedule has m on-time jobs. $\mathcal{S}={\mathcal{S}}_T\bigcup \{J_{{\mathit{\pi }}_{m+1}},\cdots ,J_{{\mathit{\pi }}_n}\}=\{J_{{\mathit{\pi }}_1},\cdots ,J_{{\mathit{\pi }}_m},J_{{\mathit{\pi }}_{m+1}},\cdots ,J_{{\mathit{\pi }}_n}\}$, where ${\mathcal{S}}_T=\{J_{{\mathit{\pi }}_1},\cdots ,J_{{\mathit{\pi }}_m}\}$ is the set of on-time jobs and $J_{{\mathit{\pi }}_{m+1}},\cdots ,J_{{\mathit{\pi }}_n}$ are late-jobs. This optimal schedule ${\mathcal{S}}_T$ can be obtained by the above Moore-like algorithm in $\mathcal{O}(nlog(n\left)\right)$-time and the optimal schedule has the following property.

Property 1.

If $m<n$, the completion times of the on-time jobs are given by

$$c_{{\mathit{\pi }}_i}=P-{(1-D)}^i\left(P-\left(\sum _{j=1}^i{p}_{{\mathit{\pi }}_j}\right)\right)\le d_{{\mathit{\pi }}_i},$$

(15)

for $i=1,\cdots ,m$. If $m=n$, we can further have that the completion time of the $J_{{\mathit{\pi }}_n}$ job is given by

$$c_{{\mathit{\pi }}_n}=P=\sum _{i=1}^n{p}_{{\mathit{\pi }}_i}\le d_{{\mathit{\pi }}_n}.$$

(16)

Property 1 gives a necessary condition for an optimal schedule of n jobs. It is the key idea behind the algorithms proposed shortly.

3.1.2. Idea Behind the Algorithm

For the algorithm presented in Section 3.1.1, all jobs have to be processed in-house and cannot be outsourced. Thus, the completion time of the last job is P. In our problem setting, the total number of outsourced jobs and the completion time of the last job in $\mathcal{S}$ are unknown until the optimal schedule has been found. The only known property is stated in the following.

Property 2.

If $\mathcal{S}=\{J_{{\mathit{\pi }}_1},\cdots ,J_{{\mathit{\pi }}_m}\}$ is an optimal schedule, there exists an integer t ($1\le t\le P$) such that the following conditions hold. For $i=1,\cdots ,m-1$,

$$\begin{array}{ccc}\hfill c_{{\mathit{\pi }}_i}& =& t-{(1-D)}^i\left(t-\left(\sum _{j=1}^i{p}_{{\mathit{\pi }}_j}\right)\right)\le d_{{\mathit{\pi }}_i}\hfill \end{array}$$

(17)

$$\begin{array}{ccc}\hfill c_{{\mathit{\pi }}_m}& =& t=\sum _{i=1}^m{p}_{{\mathit{\pi }}_i}\le d_{{\mathit{\pi }}_m}\hfill \end{array}$$

(18)

if $t={\sum }_{i=1}^m{p}_{{\mathit{\pi }}_i}$ is the completion time of the last on-time job.

It should be noted that Property 2 holds for all feasible schedules. The major problem is what the value of t should be.

Problem 1.

What should the value of t be?

As long as the value t for the optimal schedule is unknown, the key idea is to emulate all possible combinations of t (for $t=P,P-1,\cdots ,1$) for which the completion time of the last on-time job in the schedule and the optimal set of jobs satisfies conditions (17) and (18). For each t, the Moore-like algorithm presented in [21,22] for the late-job problem is applied to schedule the jobs. The pseudo-code is listed as Algorithm 1 below. The function FindSchedule$(t,D,{\mathcal{J}}_{EDD})$ is yet another Moore-like algorithm which finds the set of on-time jobs.

Algorithm 1: Total Number of Outsourced Jobs (TNOJ)

We repeat the function FindSchedule() for $t=P,P-1,\cdots ,1$. For each t, we can get the number of on-time jobs. So, we can search for all t to see which t gives the largest number of on-time jobs and t is just equal to the total completion times of the on-time jobs.

3.1.3. Function FindSchedule(t,D,$\mathcal{J}$)

Basically, the idea of the design of the function FindSchedule is from Hall–Leung–Li algorithm for solving their TNLJ problem (Algorithm U,  [22]). Instead of using $P={\sum }_i{p}_i$ to calculate the completion time of a job, we use t. So, the optimality property of Algorithm U also holds true for the function FindSchedule(t,D,$\mathcal{J}$).

Lemma 2.

Given an integer t and a set of jobs ${\mathcal{J}}_{EDD}$, the function FindSchedule $(t,D,{\mathcal{J}}_{EDD})$ is able to find the optimal number of on-time jobs in $\mathcal{O}(nlog(n\left)\right)$-time.

Proof. 

The proof is inspired by the proof of the Moore algorithm in the book authored by Pinedo [51]. Let ${\mathcal{S}}_k^{\prime }$ be the set of on-time jobs after the for-loop in the function FindSchedule has repeated for k times. Moreover, we let $r_k$ be the number of on-time jobs, i.e., $r_k=\left|{\mathcal{S}}_k^{\prime }\right|$. Given an integer t, for $k=1,2,\cdots ,n$, the following conditions hold.

• The number of jobs in ${\mathcal{S}}_k^{\prime }$ must be maximized.
• The completion time of the last job in ${\mathcal{S}}_k^{\prime }$, denoted as $\mathcal{l}\left({\mathcal{S}}_k^{\prime }\right)$, must be the smallest amongst other schedules consisting of $r_k$ on-time jobs.
• The total processing time of ${\mathcal{S}}_k^{\prime }$ is smaller or equal to t, i.e., ${\mathcal{P}}_k={\sum }_{J_j\in {\mathcal{S}}_k^{\prime }}{p}_j\le t$.

Condition (B) is equivalent to the condition that ${\mathcal{P}}_k$ is the smallest.

It is clear that Conditions (A)–(C) hold for $k=1$. We hypothesize that Conditions (A)–(C) hold for $k=m$. That is to say, $r_m$ is maximized and

$$\mathcal{l}\left({\mathcal{S}}_m^{\prime }\right)=t-{(1-D)}^{r_m}\left(t-{\mathcal{P}}_m\right)$$

is the smallest. Moreover ${\mathcal{P}}_m\le t$.    

For $m+1$, we can get that

$$\mathcal{l}\left({\mathcal{S}}_{m+1}^{\prime }\right)=c_{m+1}=t-{(1-D)}^{r_{m+1}}\left(t-p_{m+1}-{\mathcal{P}}_m\right)$$

Two possible cases will happen: (I) $c_{m+1}\le d_{m+1}$ and $p_{m+1}+{\mathcal{P}}_m\le t$; (II) either one of them is violated.

• Case (I): As $r_{m+1}=r_m+1$, $r_{m+1}$ must be maximized. Condition (A) holds for $k=m+1$. By the hypothesis that $k=m$, ${\mathcal{P}}_m$ is the smallest. Hence, ${\mathcal{P}}_{m+1}=p_{m+1}+{\sum }_{J_i\in {\mathcal{S}}_m^{\prime }}{p}_i\le t$ and it must be the smallest. The completion of the last job $\mathcal{l}\left({\mathcal{S}}_{m+1}^{\prime }\right)$ is $c_{m+1}$, which is the smallest for $k=m+1$. Condition (B) and Condition (C) hold for $k=m+1$.
• Case (II): As ${\mathcal{S}}_{m+1}^{\prime }={\mathcal{S}}_m^{\prime }\bigcup \left\{J_{m+1}\right\}\setminus \left\{J_{DEL}\right\}$, $r_{m+1}=r_m$. It is the largest number of on-time jobs. Condition (A) holds for $k=m+1$. The total processing time ${\mathcal{P}}_{m+1}$ is now given by

  $${\mathcal{P}}_{m+1}={\mathcal{P}}_m+p_{m+1}-p_{DEL},$$

  where $J_{DEL}=arg{max}_{J_j}\left\{p_j\right|J_j\in {\mathcal{S}}_m^{\prime }\bigcup \left\{J_{m+1}\right\}\}$. By the hypothesis that ${\mathcal{P}}_m<t$ and it is the smallest for $k=m$, ${\mathcal{P}}_{m+1}\le {\mathcal{P}}_m\le t$ as $p_{m+1}\le p_{DEL}$. Condition (C) holds for $k=m+1$. Moreover, ${\mathcal{P}}_{m+1}$ must be the smallest for $k=m+1$ and hence,

  $$\mathcal{l}\left({\mathcal{S}}_{m+1}^{\prime }\right)=t-{(1-D)}^{r_{m+1}}\left(t-{\mathcal{P}}_{m+1}\right)$$

  and $\mathcal{l}\left({\mathcal{S}}_{m+1}^{\prime }\right)$ is the smallest. Condition (B) holds for $k=m+1$.

By the principle of mathematical induction, Conditions (A)–(C) hold for $i=1,2,\cdots ,n$. For a given t, FindSchedule is able to find the maximum number of on-time jobs. The proof is completed.    □

As the function FindSchedule is applied for all possible $t\in \{P,P-1,\cdots ,1\}$, there must exist an integer t in which the number of on-time jobs is maximum and ${\sum }_{J_j\in \mathcal{S}}{p}_j=t$. As running time complexity of the function FindSchedule is $\mathcal{O}\left(n\right)$, the running time of Algorithm 1 is $\mathcal{O}\left(nP\right)$. So, we can state the following theorem without proof.

Theorem 3.

The problem $1|mt, os, g_i\left(p_i^{\prime }\right)=D{p}_i^{\prime }|{\sum }_i{U}_i$ can be solved by Algorithm 1 in $\mathcal{O}(nlog(n\left)P\right)$-time.

3.1.4. Bounds on t ($t_{min}$ and $t_{max}$)

As a matter of fact, the values of t can be restricted to $[t_{min},t_{max}]$, $1\le t_{min}<t_{max}\le P$. The maximum (resp. minimum) value t in Algorithm 1 can be smaller (resp. larger) than P (resp. 1). In such cases, the computational complexity of Algorithm 1 is given by $\mathcal{O}(nlog\left(n\right)(t_{max}-t_{min})$ instead of $\mathcal{O}(nlog(n\left)P\right)$.

To obtain the value $t_{max}$, we can apply the Moore algorithm [52] for scheduling n jobs. Let m be the number of on-time jobs obtained by the Moore algorithm [52]. The value $t_{max}$ can be defined as the sum of the m largest processing times.

To obtain the value $t_{min}$, we can apply the Algorithm U introduced in (Algorithm U, [22]). Let $m^{\ast }$ be the number of on-time jobs obtained. The value $t_{min}$ can be defined as the sum of the total processing times of the $m^{\ast }$ on-time jobs obtained.

The following theorem states that the maximum number of on-time jobs in the presence of multitasking must be smaller than or equal to m.

Theorem 4.

Suppose there is a list of n jobs and the number of on-time jobs obtained by the Moore algorithm is m, where $m\le n$. If $g_i\left(p_i^{\prime }\right)=D{p}_i^{\prime }$ for $i=1,\cdots ,n$, the maximum number of on-time jobs obtained by Algorithm 1 must not be larger than m.

Proof. 

The proof is based on the method of contradiction. Consider that $g_i\left(p_i^{\prime }\right)=D{p}_i^{\prime }$ for $i=1,\cdots ,n$ and there exists a schedule ${\mathcal{S}}^{\prime }=\{J_{{\mathit{\pi }}_1},\cdots ,J_{{\mathit{\pi }}_{m^{\prime }}}\}$ which consists of $m^{\prime }>m$ on-time jobs. The sum of the on-time jobs’ processing time is $P_{m^{\prime }}$. We can then get for

• $i=1,\cdots ,m^{\prime }$ that

  $$\begin{array}{ccc}\hfill c_{{\mathit{\pi }}_i}& =& P_{m^{\prime }}-{(1-D)}^i\left(P_{m^{\prime }}-\left(\sum _{j=1}^i{p}_{{\mathit{\pi }}_j}\right)\right)\le d_{{\mathit{\pi }}_i}\hfill \end{array}$$

  (19)

  $$\begin{array}{ccc}{c}_{{\mathit{\pi }}_m^{\prime }}& =& P_{m^{\prime }}\le d_{{\mathit{\pi }}_m^{\prime }}.\hspace{1em}\hspace{1em} \hspace{1em}\hspace{1em}\hspace{1em} \hspace{1em}\hspace{1em} \hspace{1em}\hspace{1em} \hfill \end{array}$$

  (20)

For the first equality, we can equivalently get for (19) that

$$c_{{\mathit{\pi }}_i}=\sum _{j=1}^i{p}_j+\left(1-{(1-D)}^i\right)\sum _{j=i+1}^{m^{\prime }}{p}_{{\mathit{\pi }}_j}$$

for $i=1,\cdots ,m^{\prime }-1$. As $c_{{\mathit{\pi }}_i}\le d_{{\mathit{\pi }}_i}$, we can definitely get that ${\sum }_{j=1}^i{p}_j\le d_{{\mathit{\pi }}_i}$ and hence the schedule ${\mathcal{S}}^{\prime }$ must be an optimal schedule in the absence of multitasking. The number of on-time jobs in the absence of multitasking is larger than m which contradicts to the m on-time jobs obtained by the Moore algorithm for the TNLJ problem in the absence of multitasking. Therefore, the number of on-time jobs obtained by Algorithm 1 must not be larger than $m^{\ast }$.    □

The following theorem states that the minimum number of on-time jobs in the presence of multitasking must be larger than or equal to $m^{\ast }$.

Theorem 5.

Suppose there is a list of n jobs and the number of on-time jobs obtained by the Algorithm U (Algorithm U, [22]) is $m^{\ast }$, where $m^{\prime }\le n$. If $g_i\left(p_i^{\prime }\right)=D{p}_i^{\prime }$ for $i=1,\cdots ,n$, the minimum number of on-time jobs obtained by Algorithm 1 must not be smaller than $m^{\ast }$.

Proof. 

Let $m^{\ast }$ be the number of on-time jobs. For $i=1,\cdots ,m^{\ast }$, we can have that

$$\begin{array}{ccc}\hfill c_{{\mathit{\pi }}_i}& =& P-{(1-D)}^i\left(P-\left(\sum _{j=1}^i{p}_{{\mathit{\pi }}_j}\right)\right)\hfill \\ & =& \left(1-{(1-D)}^i\right)P+{(1-D)}^i\left(\sum _{j=1}^i{p}_{{\mathit{\pi }}_j}\right)\le d_{{\mathit{\pi }}_i}.\hfill \end{array}$$

(21)

If we set $t_{min}={\sum }_{j=1}^{m^{\ast }}{p}_{{\mathit{\pi }}_j}$, it is clear that $c_{{\mathit{\pi }}_i}\le d_{{\mathit{\pi }}_i}$ for $i=1,\cdots ,m^{\ast }$ and for $t=t_{min},\cdots ,P$. Therefore, the number of on-time jobs obtained by Algorithm 1 must not be smaller $m^{\ast }$.    □

In this regard, we do not need to apply the FindSchedule function starting from $t=P$. Instead, we start from $t=t_{max}$ and then $t=t_{max}-1$ and so on until $t=t_{min}$. Thus, Algorithm 1 can solve the TNLJ problem in $\mathcal{O}(nlog\left(n\right)(t_{max}-t_{min}))$-time.

3.2. Total Weighted Number of Outsourced Jobs

By using the same idea as in Algorithm 1, a pseudo-polynomial algorithm can be developed for solving the problem t$1|mt, os, g_i\left(p_i^{\prime }\right)=D{p}_i^{\prime }|{\sum }_i{w}_i{U}_i$. Here, let us state an important property for the optimal schedule for the TWNOJ problem.

Property 3.

If $\mathcal{S}=\{J_{{\mathit{\pi }}_1},\cdots ,J_{{\mathit{\pi }}_m}\}$ is an optimal schedule and $({\sum }_i{w}_i-W_{max})$ is the minimum total weighted number of outsourced jobs, there exists an integer $t\in \{1,2,\cdots ,P\}$ such that the following conditions hold. For $i=1,\cdots ,m-1$,

$$\begin{array}{ccc}\hfill \hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}{c}_{{\mathit{\pi }}_i}& =& t-{(1-D)}^i\left(t-\left(\sum _{j=1}^i{p}_{{\mathit{\pi }}_j}\right)\right)\le d_{{\mathit{\pi }}_i}\hfill \end{array}$$

(22)

$$\begin{array}{ccc}\hfill c_{{\mathit{\pi }}_m}& =& t\le d_{{\mathit{\pi }}_m},\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hfill \end{array}$$

(23)

if t is the completion time of the last on-time job and

$$\sum _{J_j\in \mathcal{S}}{w}_j=W_{max}.$$

(24)

3.2.1. Idea Behind the Algorithm

By Property 3, the Algorithm WU1 in [22] can be applied for the TWNOJ problems given that the last scheduled job completion time is t. In this regard, repeating the Algorithm WU1 for $t=P,P-1,\cdots ,1$ and comparing the ${\sum }_{J_j\in \mathcal{S}}{w}_j=W_{max}$, the optimal schedule can be found.

3.2.2. Algorithm TWNOJ

We introduce the optimal value function as $W(j,k,t^{\prime },t)$, where $t=P,P-1,\cdots ,1$ and $t^{\prime }=0,1,\cdots ,t$. To evaluate the value for $W(j,k,t^{\prime },t)$, $n+1$ tables of size $(n+1)\times (t+1)$ are needed for each $t\in \{P,P-1,\cdots ,1\}$. The boundary conditions are defined in a similar way as in Algorithm WU1. For $t=P,P-1,\cdots ,1$ and $t^{\prime }=0,1,\cdots ,t$,

$$W(j,k,t^{\prime },t)=\left\{\begin{array}{cc}0\hfill & \mathrm{if} t^{\prime }=0 \mathrm{and} k=0,\hfill \\ -\infty \hfill & \mathrm{if} t^{\prime }=0 \mathrm{and} k\ge 1,\hfill \\ -\infty \hfill & \mathrm{if} t^{\prime }\ge 1 \mathrm{and} k=0,\hfill \\ -\infty \hfill & \mathrm{if} t^{\prime }\ge 1,k\ge 1 \mathrm{and} j<k.\hfill \end{array}\right.$$

(25)

The recurrence equation for $j,k=1,2,\cdots ,n$ and $t^{\prime }=1,\cdots ,t$ is defined as follows:

$$\begin{array}{ccc}& & W(j,k,t^{\prime },t)=\hfill \\ & & max\{w_j+W(j-1,k-1,t^{\prime }-p_j,t),W(j-1,k,t^{\prime },t)\}\hfill \\ \hfill \end{array}$$

(26)

if $t^{\prime }\ge p_j$ and $c(j,k,t^{\prime },t)\le d_j$. Otherwise,

$$W(j,k,t^{\prime },t)=W(j-1,k,t^{\prime },t),$$

(27)

where

$$c(j,k,t^{\prime },t)=t-{(1-D)}^k(t-t^{\prime }).$$

(28)

The optimal solution can be found in $W(n,k,t^{\prime },t)$ for all $k=0,1,\cdots ,n$, $t^{\prime }=0,1,\cdots ,t$ and $t=0,1,\cdots ,P$, the maximum value, i.e.,

$$W_{max}=\underset{k=0,1,\cdots ,n;t^{\prime }=0,1,\cdots ,t;t=0,1,\cdots ,P}{max}\left\{W(n,k,t^{\prime },t)\right\}.$$

(29)

It should be noted that the tables for $W(j,k,t^{\prime },P)$ are essentially the same as the tables obtained by the Algorithm WU1 in [22]. Therefore, the algorithm defined by (25), (26), (28) and (29) can not only solve our TWNOJ problem, but it can also solve the TWNLJ problem introduced in [22].

3.2.3. Illustrative Example

Figure 1 shows the results of the problem with the specifications listed in Table 2. Note that there are more than 20 sets of tables. Here, only the tables for $t=20$ are depicted as it contains the information for the optimal schedule. The optimal schedule is $\mathcal{S}=\{J_1,J_3,J_4\}$. Job $J_2$ is outsourced. The outsourcing charge is 4. The maximum weighted number of on-time jobs is 17.

Table 2. Illustrative example.

Jobs	${\mathit{J}}_1$	${\mathit{J}}_2$	${\mathit{J}}_3$	${\mathit{J}}_4$
$p_i$	6	3	6	8
$d_i$	8	12	14	20
$w_i$	5	4	7	5
$g_i\left(p_i^{\prime }\right)=0.1\times p_i^{\prime }$.

In comparison with the TWNLJ setting in [22], the optimal schedule obtained by the Hall–Leung–Li Algorithm WU1 is $\{J_2,J_3,J_4\}$ and $J_1$ is the late-job. The maximum weighted number of on-time jobs is 16, i.e.,

$$\underset{k=0,1,\cdots ,4;t^{\prime }=0,1,\cdots ,23}{max}\left\{W(4,k,t^{\prime },23)\right\}.$$

Figure 1. Algorithm 2 is applied to solve the problem specified in Table 2. Here only the tables for $t=20$ and $k=0,1,2,3$ are shown. The table for $k=4$ is omitted as $W(j,4,t^{\prime },20)$ are all $-\infty$. Once the algorithm has been completed, we can check from those $t^{\prime }={\sum }_{i=1}^m{p}_{{\mathit{\pi }}_i}$ for the minimum $W(·,·,·,·)$. Its corresponding schedule is an optimal schedule which minimizes the total weighted number of outsourcing jobs (equi. total outsourcing cost) ${\sum }_{i=1}^n{w}_i{U}_i$.

Figure 1. Algorithm 2 is applied to solve the problem specified in Table 2. Here only the tables for $t=20$ and $k=0,1,2,3$ are shown. The table for $k=4$ is omitted as $W(j,4,t^{\prime },20)$ are all $-\infty$. Once the algorithm has been completed, we can check from those $t^{\prime }={\sum }_{i=1}^m{p}_{{\mathit{\pi }}_i}$ for the minimum $W(·,·,·,·)$. Its corresponding schedule is an optimal schedule which minimizes the total weighted number of outsourcing jobs (equi. total outsourcing cost) ${\sum }_{i=1}^n{w}_i{U}_i$.

Algorithm 2: FindSchedule $(t,D,\mathcal{J})$ (Moore-Like Algorithm)

3.2.4. Optimality

It is clear that Algorithm TWNOJ can identically apply Algorithm WU1 in [22] repeatedly for $t\in \{P,\cdots ,1\}$; the optimality property of the Algorithm WU1 holds for Algorithm TWNOJ. The running time complexity of Algorithm TWNOJ is $\mathcal{O}\left(n{P}^2\right)$. So, the reader could refer to the Lemma 3 in [22] for the optimality proof. We can state without proof the following theorem.

Theorem 6.

The problem $1|mt, os, g_i\left(p_i^{\prime }\right)=D{p}_i^{\prime }|{\sum }_i{w}_i{U}_i$ can be solved by Algorithm TWNOJ in $\mathcal{O}\left(n{P}^2\right)$-time.

Proof. 

By Lemma 4, [22] and Algorithm WU2, [22], the problem $1|mt, os, g_i\left(p_i^{\prime }\right)=D{p}_i^{\prime }|{\sum }_i{w}_i{U}_i$ with a fixed t can be solved in $\mathcal{O}\left(nt\right)$-time. Repeating for $t=P,P-1,\cdots ,1$, we can get that the complexity of the Algorithm TWNOJ is $\mathcal{O}\left(n{P}^2\right)$. □

4. Conclusions

In Ref. [22], Hall, Leung and Li have introduced two late-jobs problems in the presence of multitasking. In their settings, the in-house worker has to process all the jobs, i.e., no job is outsourced. The worker has to handle the interruptions from the owners of the late-jobs and clearly the productivity of the worker is affected. In this paper, we have introduced two parallel problems in which some jobs are allowed to be outsourced to freelance workers and each freelancer can only work on one outsourced job. As a result, the owners of the outsourced jobs will no longer interrupt the in-house worker. All in-house jobs and outsourced jobs can be completed on-time. These parallel problems are called multitasking scheduling problems with outsourcing. A real case regarding project supervision is presented in Section 1.1.3.

4.1. Our Accomplishments

In reference to the classical late-job problems [51,53], two objectives are investigated. We assume that (i) the jobs’ processing times $p_1,\cdots ,p_n$, (ii) their due dates $d_1,\cdots ,d_n$, (iii) their outsourcing costs $w_1,\cdots ,w_n$ and (iv) their interruption models $g_i\left(k\right)$ are available at time $t=0$; (v) the actual processing time of a job ${\tilde{p}}_i$ is identical to the information $p_i$ available at time $t=0$, i.e., ${\tilde{p}}_i=p_i$ for $i=1,\cdots ,n$ and (vi) there is only one working team processing the on-time jobs. For the first objective, it is assumed that the service charges of all the jobs are the same. So, the problem is to find a schedule to minimize the total number of outsourced jobs (TNOJ). It is denoted by $1|mt, os|{\sum }_i{U}_i$, where $U_i=1$ if the job $J_i$ is outsourced. Otherwise, $U_i=0$. For the second objective, it is assumed that each job has its own service charge, say $w_i$ for $i=1,\cdots ,n$. So, the problem is to find a schedule to minimize the ‘total weighted number of outsourced jobs’ (TWNOJ). This problem is denoted by $1|mt, os|{\sum }_i{w}_i{U}_i$. Accordingly, it is proved that the TNOJ problem is NP-hard and the TWNOJ is strongly NP-hard. For the special case that $g_i\left(p_i^{\prime }\right)=D{p}_i^{\prime }$, where $p_i^{\prime }$ is the remaining processing time, an $\mathcal{O}(nlog(n\left)P\right)$-time algorithm has been developed for solving the TNOJ problem and an $\mathcal{O}\left(n{P}^2\right)$-time algorithm has been developed for solving the TWNOJ problem.

4.2. Future Works

If the actual processing time of a job ${\tilde{p}}_i$ is not identical to the information $p_i$ available at time $t=0$, sensitivity analysis [48,49] on the algorithms proposed in this paper could be a valuable future endeavour. It should be noted that sensitivity analysis on the interruption proportional factor D has already been conducted and presented in [23]. If new jobs arrive whilst the scheduled jobs are being processed, dynamic scheduling algorithms [44,45] or AI-based scheduling algorithms [46,47] might aid in scheduling those not-yet-complete jobs with better performance.

Finally, it should be noted that the objectives, respectively TNOJ and TWNOJ, investigated in this paper can be treated as the total outsourcing costs. For other objectives defined in classical scheduling, like the total weighted completion time, the maximum (weighted) lateness, common due date assignment and others [3,4,51,53], their physical meanings in relation to scheduling problems with human factors are yet to be identified.