Allocating Small Transporters to Large Jobs

Abstract

We optimize the assignment of transporters to several jobs. Each job consists of processing a large, decomposable volume. A fleet of transporters is given, each of which can only process a limited volume at a time. After processing its share, a transporter must rest for a short time before being able to process another part. This time is only dependent on the assigned job, not on the transporter. Other transporters can take over the processing while a transporter rests. Transporters assigned to the same job wait for their turn in a queue. A transporter can only be assigned to one job. Our goal is to simultaneously minimize the maximum job completion time and the number of assigned transporters by computing the frontier of Pareto optimal solutions. In general, we show that it is NP-hard in the strong sense to compute even a single point on the Pareto frontier. We provide exact methods and heuristics to compute the Pareto frontier for the general problem and compare them computationally.

1. Introduction

In many farming or construction processes, transporter resources are used to carry material to or from the operation site in a cyclic fashion. Examples for such applications are tractors collecting silage from a forage harvester, dump trucks getting filled with excavated earth, or cement or asphalt being fed from trucks to construction sites. Transporters are available on site for a limited amount of processing time, dependent on the loading capacity of the transporter and the processing speed of the main resource.

After that, they have to unload/reload material in some central hub (e.g., a harvest silo, asphalt producer, etc.) before returning to the processing site. The time of absence depends on the distance between the operation site and the hub, but it is the same for all transporters assigned to the same site. Multiple transporters may be assigned to the same working site, so that processing can continue even when some transporters are on-road toward/from the central hub. If no other transporter is available on site, the main work has to pause until the next transporter arrives back on site. Two transporters may not be used for on-site processing at the same time.

This kind of transporter setting is referred to by Jensen et al. [1] as capacitated field operations. Many instances of these types of processes have been studied in the literature from different angles, with different goals, and for different applications, see [1,2,3,4,5,6,7,8]. Recent reviews are provided in [9,10]. The important common feature of all these use cases is that the total volume that needs to be processed on site is usually much larger than the capacity of a single transporter. Figure 1 illustrates such a process for the example of farming.

Since, usually, this type of problem is NP-hard (not solvable in polynomial time unless $\mathrm{P}=\mathrm{NP}$, see [11]) when viewed as a whole (see [5]), authors turn to mathematical programming formulations (see [2,5,12]) or (meta-)heuristics (see [4,5]).

In this paper, instead, we do not consider the problem as a whole but instead investigate one specific, important sub-problem, namely the assignment of transporters to operation sites. This problem gives rise to an interesting, new scheduling problem, which, to the best of our knowledge, has not been studied in the literature before.

1.1. Formal Problem Definition

For the purpose of this study, we assume that each operation site is assigned exactly one main resource. Otherwise, we split an operation site into multiple neighboring sites, one for each resource assigned. Furthermore, we assume that the processing speed of the main resources is fixed. This is reasonable for tactical planning if the tasks conducted at each site as well as the resources used to do so are similar.

Formally, a set of jobs $\mathcal{J}$ = $\{j_1,\dots ,j_{N_J}\}$ is given, each representing one operation site together with a main resource. Furthermore, let $\mathcal{R}$ = $\{r_1,\dots ,r_{N_R}\}$ be the set of transporters. In normal scheduling terminology, the transporters would be called resources or machines; however, we stay with the term transporters throughout this paper in order to stay closer to the terminology in our field of application.

Each job has a certain volume that needs to be processed before the job is complete, and each transporter has a certain capacity that can be used up before the transporter has to rest (travel to the central hub). Since we assume the processing speed of the main resources to be fixed, we can translate all volumes into time values for ease of notation. Thus, each job $j\in \mathcal{J}$ has a saturated processing time $C^{\mathrm{sat}}\left(j\right)>0$, which is the total time it needs to be processed by transporters before it is complete. Similarly, each transporter $r\in \mathcal{R}$ has a filling time $\kappa \left(r\right)>0$, which is the time it can process a job before it needs to rest. Finally, we denote by $\delta \left(j\right)>0$ the return time of every transporter assigned to job j. In this paper, we do not allow a transporter to be assigned to multiple jobs. Figure 2 shows how two transporters may process the same job.

We assume all jobs start processing at the same time. The completion time $C\left(j\right)$ of a job $j\in \mathcal{J}$ is given as the sum of $C^{\mathrm{sat}}\left(j\right)$ and all idle times happening during the processing of job j due to no transporter being available. In particular, $C^{\mathrm{sat}}\left(j\right)$ is the completion time of job j if job j is never idle (always has a transporter available for processing). Our goal is to minimize the maximum completion time of any job, which is also called the makespan $C^{*}={max}_{j\in \mathcal{J}}C\left(j\right)$. A short makespan is desirable, because it ties in directly with several crucial performance indicators, such as the necessary opening times of the hub, potential overtime pay for workers, as well as minimizing the time frame in which problems (e.g., due to weather) may happen. In addition, a large makespan may indicate unnecessary idle times for the main resources, which are to be avoided in order to operate cost efficiently.

However, it may not be possible to hire enough transporters to avoid all idle times (due to transporter availability), or, if it is possible, it may still not be economically desirable (due to drivers’ wages) in cases where an additional transporter would only decrease the idle time by a marginal value. Thus, the total number of assigned transporters is another important measure for the quality of a solution. Therefore, our goal in this paper is to jointly minimize the makespan of multiple simultaneously operated sites and minimize the number of used transporters. The problem of assigning transporters to jobs in order to minimize simultaneously the makespan and the number of assigned transporters is called the transporter allocation problem or $\left(\mathrm{TAP}\right)$ for short.

As the two objectives of $\left(\mathrm{TAP}\right)$ are conflicting, our goal is to find all Pareto optimal solutions. A feasible solution to $\left(\mathrm{TAP}\right)$ is Pareto optimal if every other feasible solution with smaller makespan uses a larger number of transporters, and every other feasible solution that uses a smaller number of transporters has a larger makespan. The set of all Pareto optimal solutions is called the Pareto frontier. We refer to [13] for a general introduction to multicriteria optimization.

In the Appendix A, we prove that given a set $R\subset \mathcal{R}$ of transporters assigned to some job $j\in \mathcal{J}$, the completion time of j can be estimated by

$$C\left(j\right)=C^{\mathrm{sat}}\left(j\right)\frac{L\left(j\right)}{L\left(j\right)-I\left(j\right)},$$

(1)

where

$$L\left(j\right):=max\left\{\sum _{r\in R}\kappa \left(r\right),\delta \left(j\right)+\underset{r\in R}{max}\kappa \left(r\right)\right\},$$

(2)

and

$$I\left(j\right):=L\left(j\right)-\sum _{r\in R}\kappa \left(r\right).$$

(3)

The estimate depends on the practical assumption, mentioned above, that jobs are very large compared to transporter capacities and return times. See Theorem A1 for details. We also call $L\left(j\right)$ the period length and $I\left(j\right)$ the idle time per period of job j, according to the statements of Lemma A2 in the Appendix A. For the remainder of this paper, we do not deal with the exact scheduling and sequencing of transporters when processing jobs and instead only focus on the assignment of transporters to jobs using Equation (1) to estimate the completion times of the jobs. Therefore, a solution to $\left(\mathrm{TAP}\right)$ is fully given by an assignment of transporters to jobs, which are encoded by variables $\underset{X}{¯}=\left(\underset{X}{¯}{}_{r,j}\right)$ in the following way:

$$\underset{X}{¯}{}_{r,j}=\left\{\begin{array}{cc}1\hfill & \mathrm{if} \mathrm{transporter} r \mathrm{is} \mathrm{assigned} \mathrm{to} \mathrm{job} j\hfill \\ 0\hfill & \mathrm{otherwise}.\hfill \end{array}\right.$$

For a solution $\underset{X}{¯}$, we denote by $\underset{Y}{¯}{}_j\left(\underset{X}{¯}\right)$ the number of transporters assigned to j under assignment $\underset{X}{¯}$:

$$\underset{Y}{¯}{}_j\left(\underset{X}{¯}\right)=\sum _{r\in \mathcal{R}}\underset{X}{¯}{}_{r,j}.$$

In addition, by $\underset{Y}{¯}\left(\underset{X}{¯}\right)$, we denote the total number of transporters assigned by assignment $\underset{X}{¯}$, i.e.,

$$\underset{Y}{¯}\left(\underset{X}{¯}\right)=\sum _{j\in \mathcal{J}}\underset{Y}{¯}{}_j\left(\underset{X}{¯}\right).$$

Furthermore, we denote by $C^{*}\left(\underset{X}{¯}\right),C(j,\underset{X}{¯}),L(j,\underset{X}{¯})$, and $I(j,\underset{X}{¯})$ the makespan, completion time of job $j\in \mathcal{J}$, its period length, and its idle time per period, under solution $\underset{X}{¯}$, respectively. If there is no confusion about the solution referred, we may instead leave out $\underset{X}{¯}$ as before.

Note that all mathematical notation introduced in this section and throughout the remainder of the paper is also given again in a concise list in the Abbreviations section at the end of this paper.

Finally, a solution $\underset{X}{¯}$ saturates a job $j\in \mathcal{J}$ if job j has no idle time under solution $\underset{X}{¯}$, that is if $L(j,\underset{X}{¯})={\sum }_{r\in \mathcal{R}}\underset{X}{¯}{}_{i,j}\kappa \left(r_i\right)$ and $I(j,\underset{X}{¯})=0$. If solution $\underset{X}{¯}$ saturates all jobs $j\in \mathcal{J}$, then $\underset{X}{¯}$ is called saturating. Recall that in this case, the completion time of every job j is at its minimum value $C^{\mathrm{sat}}\left(j\right)$. Note that a saturating solution minimizes both the maximum and total completion time of all jobs. An instance of problem $\left(\mathrm{TAP}\right)$ is saturated if there exists at least one saturating assignment.

The remainder of this paper is structured as follows. To finish Section 1 below, we briefly summarize our results and contributions. Then, in Section 2, we present a review of the literature related to our problem. In Section 3, we state and prove some structural properties of $\left(\mathrm{TAP}\right)$, in particular that $\left(\mathrm{TAP}\right)$ is NP-hard. In Section 4, we consider the special case where transporters are identical. In Section 5, we discuss the restricted problem of finding saturated solutions, where adding a transporter cannot further decrease any completion time. Our single objective is to minimize the the number of transporters. In Section 6, we develop algorithms to compute a Pareto frontier for the general problem, using results from the saturated problem. We present simulation results in Section 7. Finally, in Section 8, we conclude our paper.

1.2. Our Results

As mentioned before, to the best of our knowledge, this is the first paper to study the problem $\left(\mathrm{TAP}\right)$ as presented here explicitly. We show that computing even a single point on the Pareto front for an instance of problem $\left(\mathrm{TAP}\right)$ is, in general, NP-hard in the strong sense. It remains NP-complete in the strong sense even if all jobs have the same return time and/or saturated processing time.

In terms of positive results, we show that the minimum number of transporters needed to saturate a job can be computed in $\mathcal{O}\left((N_R+N_J)log\left[N_R\right]\right)$ time for all jobs. Furthermore, if all transporters are identical, then the whole Pareto front to solve problem $\left(\mathrm{TAP}\right)$ can be computed in $\mathcal{O}\left((N_R+N_J)log\left[N_J\right]\right)$ time. In that case, a single point on the Pareto front can also be computed in $\mathcal{O}\left(N_J·log\left[{max}_j\left\{C(j,1)\right\}\right]\right)$ time, where $C(j,1)$ denotes the processing time of a job when exactly one transporter is assigned to it. This time complexity may in some cases be better as $N_R$ is no longer part of the estimate. See also

Table 1. Overview of complexity results for problem $\left(\mathrm{TAP}\right)$. Note that $\delta \left(j\right)={\delta }^{*}$ denotes the case where all return times are identical and $\kappa \left(r\right)={\kappa }^{*}$ denotes the case where all transporter capacities are identical. Finally, $C(j,1)$ denotes the completion time of job j when exactly one transporter is assigned to it, in the case where all transporters have identical capacity.

Version	Whole Pareto Front	Single Pareto Point	Reference
General	str. NP-hard	str. NP-hard	Section 3
$\delta \left(j\right)={\delta }^{*}$	str. NP-hard	str. NP-hard	Section 3
$\kappa \left(r\right)={\kappa }^{*}$	$\mathcal{O}\left((N_R+N_J)log\left[N_J\right]\right)$	$\mathcal{O}\left(N_J·log\left[{max}_j\left\{C(j,1)\right\}\right]\right)$	Section 4

for an overview of our complexity results.

In addition to these complexity results for sub-problems and special versions, we also consider how to solve the general problem. We suggest several approaches using mathematical programming, heuristics, and combinations of both. We evaluate all suggested algorithms experimentally and discuss their advantages and disadvantages when compared to each other.

2. Literature Review

In this section, we outline how the transporter allocation problem studied in this paper ties in with the wider literature. As mentioned before, to the best of our knowledge, $\left(\mathrm{TAP}\right)$ has not been studied in this form before. However, there are several optimization problems that bear a resemblance to $\left(\mathrm{TAP}\right)$. Below, we focus on the two most closely related problems, namely divisible load scheduling, which can be seen as a version of $\left(\mathrm{TAP}\right)$ where transporters may process the job in parallel rather than in sequence, and multiple knapsack problems, which relate to $\left(\mathrm{TAP}\right)$ in the way that for each job, there is an upper limit of transporter sizes before adding more transporters no longer improves anything. We compare the problems to $\left(\mathrm{TAP}\right)$ and explain which, if any, results can be transferred to our setting.

We will not consider papers discussing capacitated field operations in general again, as in the beginning of Section 1, since other than providing the wider practical motivation, they have little relevance for $\left(\mathrm{TAP}\right)$. Furthermore, note that even though both problems stem from logistic tasks, $\left(\mathrm{TAP}\right)$ is not comparable to vehicle routing problems. In vehicle routing problems [14], each transporter is usually assigned several delivery jobs, while for $\left(\mathrm{TAP}\right)$, each job is assigned several transporters. Due to this fundamental difference, even though the problems may look related in practice, they are not close from a mathematical perspective.

2.1. Divisible Load Scheduling

In divisible load scheduling [15], a processing load needs to be divided onto several processors, just like the total volume of a job in $\left(\mathrm{TAP}\right)$ needs to be divided onto several transporters. The main difference between the two is that in divisible load scheduling, the processors are assumed to be parallel, such that they are allowed to process different parts of the main load at the same time. In addition, usually, in divisible load scheduling problems, only a single load needs to be split across processors, while for $\left(\mathrm{TAP}\right)$, multiple loads need to be assigned to transporters. Note that without any further assumptions, splitting a load over parallel processors is usually easy. Therefore, the literature considers many additional parameters, such as setup times, communication delays between processors, and more complex processor networks (e.g., where sub-processors on the first level have again several second-level sub-processors to which they can divide their sub-task). We refer to [16] for a review. In comparison, as we show in this paper, $\left(\mathrm{TAP}\right)$ is much harder, even without any additional assumptions.

Interestingly, many papers consider bi-criteria versions of divisible load scheduling, where the goal is to minimize the makespan and cost of a schedule simultaneously; see [17,18,19]. Here, cost is usually defined as a function of the load assigned to each processor, together with a fixed cost to activate each used processor in the first place [19]. Special versions have been studied without any additional restrictions and where only the fixed cost for each processor is used [17,19]. Note that this version is very close to $\left(\mathrm{TAP}\right)$ with only three differences: first, of course, for the divisible load scheduling problem, the processors work in parallel, whereas for $\left(\mathrm{TAP}\right)$, they in sequence; second, in the divisible load scheduling problem, processors may have different speeds but have no maximum load, whereas in $\left(\mathrm{TAP}\right)$, all transporters have the same speed but a maximum capacity after which they must rest; third, for $\left(\mathrm{TAP}\right)$, we assume additionally that the fixed cost for each transporter is the same. This special version of divisible load scheduling is shown to be NP-hard in the usual sense [17]. We prove later that $\left(\mathrm{TAP}\right)$ is NP-hard in the strong sense. Furthermore, note that if in the divisible load scheduling problem the fixed cost of all processors is the same, then the NP-hardness proof from [17] is no longer valid, while this assumption holds by definition for $\left(\mathrm{TAP}\right)$.

Most other results for divisible load scheduling are not comparable to $\left(\mathrm{TAP}\right)$ either due to additional restrictions for the divisible load scheduling problem or because of the difference in sharing load in parallel or sequential. Thus, techniques used to solve divisible load scheduling problems cannot be easily transferred to $\left(\mathrm{TAP}\right)$.

2.2. Multiple Knapsack Problems

Even though it is not immediately obvious from a practical point of view, $\left(\mathrm{TAP}\right)$ is rather strongly related to multiple knapsack problems. Recall that the knapsack problem [20] is a popular optimization problem, with the objective to select items with maximum total value without exceeding a certain capacity. The multiple knapsack problem considers several knapsacks with potentially different capacities. The objective is to assign items to knapsacks such that the total items value is maximized without exceeding any knapsack capacity. In comparison, for $\left(\mathrm{TAP}\right)$, consider each job as a knapsack with a capacity given by the total size of transporters needed before all idle times vanish (note that this capacity is not fixed, as it depends on the largest transporter assigned, cf. Equation (2)). Then, a good allocation of transporters is one where each “knapsack” is as close to exactly filled as possible.

Many knapsack-related problems are known to be NP-hard [11]. Most algorithms for the multiple knapsack problem are either greedy or meta-heuristics such as in [21,22], polynomial approximation schemes such as in [23,24], or exact methods using mathematical programming as in [25,26].

For our paper, a special kind of knapsack problem studied in [27] is of particular interest. In this version, so-called assignment restrictions are given, such that each item is only allowed to be assigned to as subset of the knapsacks. This is interesting, since in $\left(\mathrm{TAP}\right)$, jobs may become ineligible for further transporters once they have reached their minimum possible completion time. In [27], the authors propose several approximation algorithms, some with a simple, greedy structure. We will later (cf. Section 5) see that two of these algorithms can be adjusted to work well as heuristics for $\left(\mathrm{TAP}\right)$.

3. Structural Results

In this section, we consider the structural properties of $\left(\mathrm{TAP}\right)$ before turning to solution methods for the general problem and special cases in the remainder of the paper. In the first part of this section, we show that $\left(\mathrm{TAP}\right)$ is NP-hard in the strong sense. In the second part of this section, we introduce lower bounds on the number of transporters needed for a job to be saturated, i.e., have no idle time. We also provide an easy algorithm to compute all such lower bounds for a general instance of $\left(\mathrm{TAP}\right)$.

3.1. NP-Hardness of $\left(\mathrm{TAP}\right)$

Unfortunately, $\left(\mathrm{TAP}\right)$ is NP-hard in the strong sense, i.e., not solvable in time polynomial in the size of the input, even if the input is encoded in unary encoding, unless $\mathrm{P}=\mathrm{NP}$, cf. [11]. In fact, we prove below that for an instance of $\left(\mathrm{TAP}\right)$ it is, in general, strongly NP-hard to compute even a single point on the Pareto frontier. Let $\left(\mathrm{TAP}{}_{C^{*}}\left(n_r\right)\right)$ be the decision version of $\left(\mathrm{TAP}\right)$ with target makespan $C^{*}$. That is, given an instance of $\left(\mathrm{TAP}\right)$ and a target makespan $C^{*}$, the task for $\left(\mathrm{TAP}{}_{C^{*}}\left(n_r\right)\right)$ is to decide if there exists an assignment of transporters to jobs such that the makespan is at most $C^{*}$, and at most, $n_r$ transporters are used.

Theorem 1.

$\left(\mathrm{TAP}{}_{C^{*}}\left(n_r\right)\right)$ is NP-complete in the strong sense, even if $C^{*}$ is chosen as the minimum possible makespan, i.e., $C^{*}={max}_j\left\{C^{\mathrm{sat}}\left(j\right)\right\}$. Moreover, it remains NP-complete in the strong sense, even if all jobs have the same return time and/or saturated processing time. Finally, it remains NP-complete in the strong sense even if it reduces to the decision if a saturating assignment exists, i.e., with parameters $C^{*}=C^{\mathrm{sat}}\left(1\right)=C^{\mathrm{sat}}\left(2\right)=\dots =C^{\mathrm{sat}}\left(N_J\right)$ and $n_r=N_R$.

Proof. 

Reduction from three-partition problem, which is NP-complete in the strong sense [11]: Given a multiset S of $n=3·m$ positive integers, can S be partitioned into m triplets $S_1$, $S_2,\dots ,S_m$ such that the sum of the numbers in each subset is equal?

The subsets $S_1$, $S_2,\dots ,S_m$ must form a partition of S in the sense that they are disjoint and they cover S. Let B denote the (desired) sum of each subset $S_i$, or equivalently, let the total sum of the numbers in S be $m·B$. The three-partition problem remains strongly NP-complete when every integer in S is strictly between $\frac{B}{4}$ and $\frac{B}{2}$.

Let (I) be an arbitrary instance of three-partition with $S=s_1,\dots ,s_{3·m}$ and ${\sum }_i{s}_i=m·B$ and $B/4<s_i<B/2$.

Let M be an arbitrary large positive integer with $M>m·B$. Let $S^{\prime }$ be the multiset defined by $S+K$ with K being the multiset $\{M,\dots ,M\}$ with $\left|K\right|=2·m$. Hence, $|S^{\prime }|=5·m$. In the following, we refer to the elements from K as the large elements. Define now an instance of $\left(\mathrm{TAP}{}_{C^{*}}\left(n_r\right)\right)$ with the set of resources $\mathcal{R}$ with filling times $\kappa \left(t_i\right)=s_i^{\prime }$. The job set $\mathcal{J}$ has cardinality m and the return times $\delta \left(j\right)=B+M$ and saturated processing times $C^{\mathrm{sat}}\left(j\right)=B+M+M$ for all jobs $j\in \mathcal{J}:=\{j_1,\dots ,j_m\}$. Note that, by construction, all jobs have the same return time and the same saturated processing time.

We need to prove the following:

$$\left(I\right)\mathrm{has}\mathrm{a}\mathrm{solution}\iff \left(\mathrm{TAP}{}_{B+M+M}(5·m)\right)\mathrm{has}\mathrm{answer}\mathrm{yes}.$$

⇒: Given a solution $S_1,\dots ,S_m$ (i.e., a set of triplets with the desired properties) to the three-partition instance (I), we can easily construct a solution to $\left(\mathrm{TAP}\right)$ by first assigning the transporters with the filling times corresponding to $S_i$ to the job $j_i$. Then, each job is additionally assigned to two of the transporters of size M. Since by definition ${\sum }_{s\in S_i}s=B$, the return time of $B+M$ is covered exactly by the four smallest elements, meaning each job is saturated and no idle time occurs. By definition of the saturated processing times, this means the makespan of the constructed solution is exactly $B+M+M$.

⇐: Let $\underset{X}{¯}{}_{r,j}$ be a solution to $\left(\mathrm{TAP}\right)$ with makespan $B+M+M$ and $5·m$ resources used. By definition of our instance, all m jobs must be saturated in order to reach makespan $B+M+M$. Therefore, each job must have assigned transporters with an accumulated filling time of at least $B+M$ when ignoring the largest transporter. Since M by definition cannot be reached by using items of S, the largest and second largest transporter assigned to each job must each have filling time M. This uses up all $2m$ transporters with filling time M, and no job can have three transporters with filling time M assigned. Hence, the large items of size M are distributed equally to the jobs, leaving the items from S to cover the remaining return times of B for each job. Ignoring the large items, a solution for the three-partition instance (I) remains. □

Note that the same arguments hold if the saturated processing time of each job is instead given by $k·(B+M+M)$ for some $0<k\in \mathbb{N}$. So, the same proof also works in a more practical instance, where jobs are very large compared to transporter capacities and return times.

Note also that nearly the same reduction can be made from a usual partition problem (cf. [11]) instead of three-partition. In that case only two jobs would be constructed and four transporters of size M would be needed. Then, using the same arguments as above, it can be shown that a solution to the partition instance exists if and only if a solution to $\left(\mathrm{TAP}{}_{C^{*}}\left(n_r\right)\right)$ with $C^{*}=B+M+M$ exists, where B is the target value of the partition instance. This shows that problem $\left(\mathrm{TAP}\right)$ would remain NP-hard (in the usual sense) even if there are only two jobs.

3.2. Saturating Transporter Sets

Given a set of transporters $\mathcal{R}$ and a job j, recall that a set of transporters $R\subset \mathcal{R}$ saturates job j if

$$\sum _{r\in R}\kappa \left(r\right)\ge \delta \left(j\right)+\underset{r\in R}{max}\kappa \left(j\right).$$

Any (cardinality) smallest subset of $\mathcal{R}$ that can saturate job j is called a saturating transporter set for j. The common cardinality of all saturating transporter sets for job j is called the saturating transporter cardinality, which is denoted by $N_{\mathcal{R}}^{*}\left(j\right)$. If no saturating transporter set exists, that is, if even $\mathcal{R}$ itself cannot saturate job j, then we define $N_{\mathcal{R}}^{*}\left(j\right)=\infty$. Note that, by definition, the $N_{\mathcal{R}}^{*}\left(j\right)$ transporters in $\mathcal{R}$ with biggest filling times are a saturating transporter set for job j, if one exists.

The saturating transporter cardinality of every job is a lower bound of the number of assigned transporters to this job in any saturating assignment. Our algorithms use this concept to compute assignments.

Lemma 1.

The time complexity to compute the saturating transporter cardinality of all jobs is:

$$\mathcal{O}\left((N_R+N_J)·log\left[N_R\right]\right).$$

Proof. 

We sort the transporters by decreasing the filling time in $\mathcal{O}(N_R·log\left[N_R\right])$. Then, we remove the biggest transporter, which will be the transporter whose return time has to be covered.

For a single job, we can build a saturating transporter set by adding to the biggest transporter as many transporters as necessary from a sorted list such that their filling time exceeds the job’s return time. Since this set contains the biggest transporters, there cannot be any smaller transporter set saturating the job.

We can improve this process to compute the saturating transporter cardinality for every job. We first compute the cumulative filling times of the transporters in $\mathcal{O}\left(N_R\right)$. Then, for each, we find the minimum cumulative filling time bigger than the return time, using a binary search in $\mathcal{O}(log\left[N_R\right])$ time. Hence, for all jobs, it takes $\mathcal{O}(N_J·log\left[N_R\right])$.

Thus, the total complexity is $\mathcal{O}\left((N_R+N_J)·log\left[N_R\right]\right)$. □

4. The Homogeneous Transporter Allocation Problem

In this section, we consider the special case of $\left(\mathrm{TAP}\right)$ in which all transporters have the same filling time $\kappa$. We call instances of $\left(\mathrm{TAP}\right)$ that fulfill this condition homogeneous. Note that in this case, the saturating transporter cardinality $N_{\mathcal{R}}^{*}\left(j\right)$ of job j can be computed in $O\left(1\right)$ by the equation:

$$N_{\mathcal{R}}^{*}\left(j\right):=\lceil \frac{\delta \left(j\right)}{\kappa }\rceil +1.$$

(4)

That means that the saturating transporter cardinality of all jobs can be computed in $O\left(N_J\right)$ instead of $O\left((N_R+N_J)·log\left[N_R\right]\right)$ as in the general case.

By definition, if we assign $\underset{Y}{¯}{}_j\left(\underset{X}{¯}\right)={\sum }_r\underset{X}{¯}{}_{r,j}\ge N_{\mathcal{R}}^{*}\left(j\right)$ transporters to a job j, then the job j is saturated and its completion time is $C^{\mathrm{sat}}\left(j\right)$. Otherwise, every period takes duration $\delta \left(j\right)+\kappa$ while the effective completion time is only $\underset{Y}{¯}{}_j·\kappa$, and the job j is idle for the remaining $\delta \left(j\right)+\kappa -\underset{Y}{¯}{}_j·\kappa$ time units per period.

Then, the job completion time is:

$$\begin{array}{cc}\hfill C(j,\underset{X}{¯})& =\left\{\begin{array}{cc}{C}^{\mathrm{sat}}\left(j\right)·\left(\delta \left(j\right)+\kappa \right)/\left(\kappa ·\underset{Y}{¯}{}_j\left(\underset{X}{¯}\right)\right)\hfill & \mathrm{if}\underset{Y}{¯}{}_j<N_{\mathcal{R}}^{*}\left(j\right),\hfill \\ C^{\mathrm{sat}}\left(j\right)\hfill & \mathrm{if}\underset{Y}{¯}{}_j\ge N_{\mathcal{R}}^{*}\left(j\right)\hfill \end{array}\right..\hfill \end{array}$$

(5)

In what follows, we show that for a homogeneous instance of $\left(\mathrm{TAP}\right)$, the full frontier of Pareto optimal solutions can be computed in $\mathcal{O}\left((N_R+N_J)·log\left[N_J\right]\right)$ time.

Consider algorithm (Hom), which computes the Pareto frontier in the following steps:

1

The first Pareto solution is achieved by assigning one transporter to every job;

2

Add one more transporter to any job with maximum completion time according to Equation (5);

3

If step 2 decreased the makespan, then the new solution is a Pareto solution;

4

If any job with maximum completion time is saturated, or if all transporters are used, stop; otherwise, return to step 2.

The following theorem shows that algorithm (Hom) computes the frontier of Pareto optimal solutions in full.

Theorem 2.

If every transporter has the same filling time, Algorithm (Hom) computes a Pareto solution to $\left(\mathrm{TAP}\right)$ at every step in which the makespan decreases. Moreover, each Pareto solution is found by algorithm (Hom).

Proof. 

We prove, equivalently, that at the k-th step (including the step where the first solution is computed), Algorithm (Hom) computes a solution of minimum makespan amongst all solutions in which exactly $N_J+k-1$ transporters are used. That means that if the makespan decreases in the k-th step, the achieved solution is Pareto optimal, since any fewer number of used transporters can only achieve a strictly larger makespan. In addition, since all possible numbers of used transporters are tested once, no Pareto optimal solution is missed.

It remains to be shown that indeed, the solution computed in the k-th step has a minimum makespan amongst all solutions in which exactly $N_J+k-1$ transporters are used. Suppose that at the k-th step, the assignment is not minimizing the makespan over every solution using k transporters. Let $(\underset{Y}{¯}{}_{j_1},\dots \underset{Y}{¯}{}_{j_{N_J}})$ be the number of transporters assigned to the jobs at this step. Consider an optimal assignment of k transporters $(\underset{Y}{¯}{}_{j_1}^{*},\dots \underset{Y}{¯}{}_{j_{N_J}}^{*})$, minimizing the makespan. Pick the first iteration where the algorithm assigns a transporter to a job $j_i$ such that the number $\underset{Y}{¯}{}_{j_i}^{*}$ of the optimal solution is being exceeded. By definition, the completion time of the optimal solution is greater or equal to the completion time of $j_i$ when using $\underset{Y}{¯}{}_{j_i}^{*}$ transporters. However, by construction, at this point in time, the algorithm assignment is such that the completion time of every job is smaller than or equal to this duration. This contradicts the assumption that the maximum completion time with $\underset{Y}{¯}{}^{*}$ is strictly lower than with $\underset{X}{¯}$, hence that $\underset{Y}{¯}{}^{*}$ is optimal. □

Additionally, Algorithm (Hom) has the runtime as claimed above.

Theorem 3.

Algorithm (Hom) runs in time $\mathcal{O}\left((N_R+N_J)·log\left[N_J\right]\right)$.

Proof. 

We first compute the partial assignment of one transporter per job in $\mathcal{O}\left(N_J\right)$. Then, for at most $N_R$ iterations, we adjust the longest job and reorder the sorted list. Computing the completion time of a job takes $\mathcal{O}\left(1\right)$ time by Equation (5). If we store job completion times in a heap data structure in $\mathcal{O}(N_J·log\left[N_J\right])$, then every iteration is performed in $\mathcal{O}(log\left[N_J\right])$. Thus, the total time complexity is $\mathcal{O}((N_R+N_J)·log\left[N_J\right])$. □

Together, Theorems 2 and 3 prove our initial proposition.

Corollary 1.

For a homogeneous instance of $\left(\mathrm{TAP}\right)$, the full frontier of Pareto optimal solutions can be computed in $\mathcal{O}((N_R+N_J)·log\left[N_J\right])$ time.

Note that in the homogeneous $\left(\mathrm{TAP}\right)$, the set of transporters can be encoded in $log\left[N_R\right]$ space by simply encoding the number of transporters (all transporters are of the same type). Thus, technically, a runtime of $\mathcal{O}\left((N_R+N_J)·log\left[N_J\right]\right)$ is not polynomial in the input length. On the other hand, for a generic instance, a Pareto frontier has $\mathcal{O}\left(N_R\right)$ points, so it cannot be put out in less than $\mathcal{O}\left(N_R\right)$ steps. In scheduling, this is usually referred to as a high-multiplicity problem, see [28].

One way to resolve this issue is to show that any single Pareto point can be computed in polynomial time (with an algorithm that is at most logarithmic in $N_R$). For our algorithm, note that any single iteration of step 2 runs in $\mathcal{O}(log\left[N_J\right])$ time and that a new Pareto point is found at least every $N_J$ such iterations (after each job is assigned one more transporter). Thus, our algorithm moves from one Pareto point to the next in polynomial time. Still, in order to compute a particular point, using at most m transporters, with Algorithm (Hom), we need $\mathcal{O}\left((m+N_J)·log\left[N_J\right]\right)$ steps, which is not polynomial when $m=\mathcal{O}\left(N_R\right)$.

Instead, one can compute for a given makespan exactly the number of transporters needed to be assigned to each job via Equation (5) and then check if the total number of transporters does not exceed the given upper bound. For any given makespan, this check can be run in $\mathcal{O}\left(N_J\right)$ time, running one computation for each job. Then, via binary search using this computation at each step, one obtains a polynomial algorithm to compute a particular point on the Pareto frontier. To be precise, the obtained algorithm runs in $\mathcal{O}\left(N_J·log\left[{max}_j\left\{C(j,1)\right\}\right]\right)$, where $C(j,1)$ denotes the processing time of a job when exactly one transporter is assigned to it.

However, our primary goal is to compute the Pareto frontier as a whole, for which Algorithm (Hom) is better suited than iteratively using the suggested binary search algorithm, which would take $\mathcal{O}\left(N_R·N_J·log\left[{max}_j\left\{C(j,1)\right\}\right]\right)$ time.

5. The Saturated Transporter Allocation Problem

In this section, we consider a simplification of $\left(\mathrm{TAP}\right)$, which we call the saturated transporter allocation problem $\left(\mathrm{sTAP}\right)$. The objective of $\left(\mathrm{sTAP}\right)$ is to compute an optimal saturating assignment, that is with a minimum number of transporters and where jobs are never idle. If the transporter fleet is too small to allow such an assignment, then (sTAP) is infeasible.

Note that this simplification removes the bi-criteria nature of the problem, as the only objective is to assign as few transporters as possible, under the constraint of saturating every job. In addition, note that the solution to problem $\left(\mathrm{sTAP}\right)$ is not necessarily a point on the Pareto frontier of $\left(\mathrm{TAP}\right)$. Indeed, from a solution of $\left(\mathrm{sTAP}\right)$, it may be possible to remove some transporters from shorter jobs without increasing the makespan of the solution (but leaving shorter jobs unsaturated as a consequence). Finally, note that $\left(\mathrm{sTAP}\right)$ is NP-hard in the strong sense, by Theorem 1, where we showed that computing a point on the Pareto frontier is strongly NP-hard, even if it reduces to finding a saturating assignment.

We first provide two mixed integer programs to solve $\left(\mathrm{sTAP}\right)$: one for the general case and one optimized for the case were the transporter fleet consists of several types of similar transporters, which is more prevalent in practical settings. Then, we introduce several greedy heuristics, which we will later extend also to the solution of general $\left(\mathrm{TAP}\right)$.

5.1. General MIP Formulation

The following mixed integer program $\left(\mathrm{sMIP}\right)$ describes the saturated problem $\left(\mathrm{sTAP}\right)$, depending on the assignment $\underset{X}{¯}{}_{r,j}$, the transporter filling times $\kappa \left(r\right)$, and the return times $\delta \left(j\right)$:

$$\begin{array}{ccc}\hfill \left(\mathrm{sMIP}\right):& \hfill & \end{array}$$

$$\begin{array}{ccc}\hfill \underset{\underset{X}{¯}}{min}& \sum _{r\in \mathcal{R}}\sum _{j\in \mathcal{J}}\underset{X}{¯}{}_{r,j}\hfill & \hfill \end{array}$$

(6)

$$\begin{array}{ccc}\hfill \mathrm{s}.\mathrm{t}.& \sum _{j\in \mathcal{J}}\underset{X}{¯}{}_{r,j}\le 1,\hfill & \hfill \forall r\in \mathcal{R}\end{array}$$

(7)

$$\begin{array}{ccc}\hfill & \sum _{r^{\prime }\in \mathcal{R}}\left[\underset{X}{¯}{}_{r^{\prime },j}·\kappa \left(r^{\prime }\right)\right]-\underset{X}{¯}{}_{r,j}·\kappa \left(r\right)\ge \delta \left(j\right),\hfill & \hfill \forall r\in \mathcal{R},\forall j\in \mathcal{J}\end{array}$$

(8)

$$\begin{array}{ccc}\hfill & \underset{X}{¯}{}_{r,j}\in \{0,1\},\hfill & \hfill \forall r\in \mathcal{R},\forall j\in \mathcal{J}.\end{array}$$

(9)

Equation (8) represents the saturation constraints: the return time of each assigned transporter is covered by the total filling time of the remaining assigned transporters, hence preventing any idle time. Recall that, actually, it is sufficient to test this for the transporter with maximum capacity, leading to

$$\sum _{r\in \mathcal{R}}\left[\underset{X}{¯}{}_{r,j}·\kappa \left(r\right)\right]-\underset{t\in \mathcal{R}}{max}\underset{X}{¯}{}_{r,j}·\kappa \left(r\right)\ge \delta \left(j\right),\forall j\in \mathcal{J}.$$

However, since this is not a valid constraint for a MIP, Equation (8) is used instead.

5.2. Aggregated MIP Formulation

In the mentioned real-life applications, it is rarely the case that transporter sizes vary arbitrarily. Rather, some small number of different models or variants exist that come with different capacities. In that case, it is reasonable to exploit this by grouping transporters with the same filling time. In the following, we identify each filling time with a transporter model and rewrite $\left(\mathrm{sMIP}\right)$ after grouping the transporters by their model.

Suppose that the set of transporter models is denoted by $\mathcal{M}$, and for each $m\in \mathcal{M}$, there are $M\left(m\right)$ many transporters of model m. Furthermore, assume the filling time of transporter model m is denoted by $\kappa \left(m\right)$. Introduce variables $\underset{Y}{¯}{}_{m,j}$, denoting the number of transporters of model m assigned to job j. Additionally, the binary variable $\underset{X}{¯}{}_{m,j}$ is equal to 1 if and only if at least one transporter of model m is assigned to job j.

We denote by ${\mathbb{N}}^{+}$ the set of natural numbers, including 0. Then, the aggregated mixed integer program $\left(\mathrm{sMIP}g\right)$ is as follows:

$$\begin{array}{ccc}\hfill \left(\mathrm{sMIP}g\right):& \hfill & \end{array}$$

$$\begin{array}{ccc}\hfill \underset{\underset{X}{¯},\underset{Y}{¯}}{min}& \sum _{m\in \mathcal{M}}\sum _{j\in \mathcal{J}}\underset{Y}{¯}{}_{m,j}\hfill & \hfill \end{array}$$

(10)

$$\begin{array}{ccc}\hfill \mathrm{s}.\mathrm{t}.& \sum _{j\in \mathcal{J}}\underset{Y}{¯}{}_{m,j}\le M\left(m\right),\hfill & \hfill \forall m\in \mathcal{M}\end{array}$$

(11)

$$\begin{array}{ccc}\hfill & \underset{X}{¯}{}_{m,j}\le \underset{Y}{¯}{}_{m,j},\hfill & \hfill \forall m\in \mathcal{M},\forall j\in \mathcal{J}\end{array}$$

(12)

$$\begin{array}{ccc}\hfill & \underset{Y}{¯}{}_{m,j}\le M\left(m\right)·\underset{X}{¯}{}_{m,j},\hfill & \hfill \forall m\in \mathcal{M},\forall j\in \mathcal{J}\end{array}$$

(13)

$$\begin{array}{ccc}\hfill & \sum _{m^{\prime }\in \mathcal{M}}\left[\underset{Y}{¯}{}_{m^{\prime },j}·\kappa \left(m^{\prime }\right)\right]-\underset{X}{¯}{}_{m,j}·\kappa \left(m\right)\ge \delta \left(j\right),\hfill & \hfill \forall m\in \mathcal{M},\forall j\in \mathcal{J}\end{array}$$

(14)

$$\begin{array}{ccc}\hfill & \underset{X}{¯}{}_{m,j}\in \{0,1\},\hfill & \hfill \forall m\in \mathcal{M},\forall j\in \mathcal{J}\end{array}$$

(15)

$$\begin{array}{ccc}\hfill & \underset{Y}{¯}{}_{m,j}\in {\mathbb{N}}^{+},\hfill & \hfill \forall m\in \mathcal{M},\forall j\in \mathcal{J}.\end{array}$$

(16)

Note that the variables $\underset{X}{¯}{}_{m,j}$ are only used in the constraints from Equations (14). Since these constraints are more restrictive when $\underset{X}{¯}{}_{m,j}=1$, the solver will by default set $\underset{X}{¯}{}_{m,j}$ to 0. Therefore, we do not need to fix an upper bound for variables $\underset{X}{¯}{}_{m,j}=1$. Hence, we could omit Equation (12), but we leave it for the sake of clarity.

This new program $\left(\mathrm{sMIP}g\right)$ has $2·N_M·N_J$ variables and $N_M+3·N_M·N_J$ constraints, whereas $\left(\mathrm{sMIP}\right)$ has $N_R·N_J$ variables and $N_R+N_R·N_J$. Therefore, the size of the new program $\left(\mathrm{sMIP}g\right)$ is smaller than the size of $\left(\mathrm{sMIP}\right)$ as soon as there are at least three transporters per model.

After solving $\left(\mathrm{sMIP}g\right)$, we still need to arbitrarily assign the transporters of each model to the jobs, which can be done in $\mathcal{O}(N_R+N_J)$ time.

5.3. Greedy Algorithms

In this section, we develop three greedy algorithms for $\left(\mathrm{sTAP}\right)$, which are inspired by algorithms used for the multiple knapsack problem.

In order to illustrate the connection between $\left(\mathrm{sTAP}\right)$ and multiple knapsack problems, below, we use the wording of knapsack instances to formulate the goal of $\left(\mathrm{sTAP}\right)$. When solving a multiple knapsack problem, the goal is to pack items with given weight and value in knapsacks to maximize the total packed value without exceeding the weight capacity of any knapsack. Using the same wording, when solving the saturated transporter allocation problem, the goal is to pack items with given weight and constant value of 1 in knapsacks to minimize the total packed value while ensuring the following minimum capacity conditions: in every knapsack, the total packed item weights excluding the biggest one exceeds a minimum total weight.

In [27], the authors propose, among others, two heuristics to solve the multiple knapsack problem under additional assignment restrictions. Their first greedy heuristic consists of taking the items in non-increasing order and assigning them to the first eligible knapsack. Their second algorithm takes knapsacks in an arbitrary order and successively solves single knapsack problems using the still unassigned items.

Following these ideas, our first algorithm assigns transporters to the jobs one job after the other, whereas the second and third algorithms assign transporters one by one to the best suited job. These heuristics are later also extended to the general version of $\left(\mathrm{TAP}\right)$ in Section 6 and are computationally evaluated along with other algorithms and MIPs in Section 7.

5.3.1. Greedy Algorithm by Job

Our first greedy algorithm $\left(\mathrm{sGJ}\right)$ iterates through the jobs in order of non-increasing return times. It assigns exactly as many transporters as needed to one job at a time so that the job is saturated. If at any time during the algorithm the current job cannot be saturated, the algorithm fails.

We assume that transporters are indexed in order of non-increasing filling times. We start with transporter set ${\mathcal{R}}^{\prime }:=\mathcal{R}$. We iteratively assign to a job a saturating transporter set with respect to the current set ${\mathcal{R}}^{\prime }$ and update ${\mathcal{R}}^{\prime }$ thereafter by deleting the assigned transporters. Since the ideal transporter sets of different jobs may overlap, it cannot be guaranteed that every job j will be assigned to $N_{\mathcal{R}}^{*}\left(j\right)$ transporters.

At any iteration, for a current job j, we first compute the minimum number of transporters $N_{{\mathcal{R}}^{\prime }}^{*}\left(j\right)$ needed to saturate j using the current remaining set of transporters ${\mathcal{R}}^{\prime }$. Recall that by Theorem Section 3.2, this can be done efficiently. Then, we enumerate all subsets of ${\mathcal{R}}^{\prime }$ of size $N_{{\mathcal{R}}^{\prime }}^{*}\left(j\right)$ and assign one to j such that j is saturated. If there are multiple subsets of ${\mathcal{R}}^{\prime }$ of size $N_{{\mathcal{R}}^{\prime }}^{*}\left(j\right)$ which saturate j, then as a tie breaker, we choose the set that uses the smallest maximum indexed transporter, which is not used by all other sets. If there is still a tie, we repeat the above rule with only the still tied sets until only one candidate set is left.

For example, suppose that the current transporter set is ${\mathcal{R}}^{\prime }=\{r_1,r_2,r_3,r_4,r_5\}$, and that our current job is j with $N_{{\mathcal{R}}^{\prime }}^{*}\left(j\right)=3$. Suppose there are four subsets of ${\mathcal{R}}^{\prime }$ of size 3 that saturate job j, namely $\{r_1,r_2,r_3\}$, $\{r_1,r_2,r_4\}$, $\{r_1,r_2,r_5\}$, and $\{r_1,r_3,r_4\}$. Recall that transporters are numbered in order of non-increasing filling times. All sets use transporter $r_1$. After removing $r_1$, the transporter with maximum filling time in the first three candidates is $r_2$, while the transporter with maximum filling time in the fourth candidate is $r_3$. We pick the fourth candidate, since $r_3$ has a smaller or equal filling time compared to $r_2$.

If in the above example, $\{r_1,r_3,r_5\}$ would have been a candidate as well, then in a second round of tie breaking, our algorithm would only consider sets $\{r_1,r_3,r_4\}$ and $\{r_1,r_3,r_5\}$. After removing common transporters, only $r_4$ remains in the first set, while only $r_5$ remains in the second, leading to us choosing the later set $\{r_1,r_3,r_5\}$.

Note that the runtime of algorithm $\left(\mathrm{sGJ}\right)$ is exponential in the number of transporters, since we enumerate over a set of subsets of the transporter set. However, since all subsets have the same cardinality and this cardinality is usually relatively small, in practice, $\left(\mathrm{sGJ}\right)$ still has a reasonable runtime, as is shown in the computational experiments in Section 7.

5.3.2. Greedy Algorithms by Transporter

Algorithms $\left(\mathrm{sGR}c\right)$ and $\left(\mathrm{sGR}i\right)$ assign transporters one by one in order of non-increasing filling times.

Given currently assigned transporters, Algorithm $\left(\mathrm{sGR}c\right)$ assigns the next transporter to the non-saturated job with maximum completion time, whereas Algorithm $\left(\mathrm{sGR}i\right)$ assigns it to the non-saturated job with maximum idle time per period.

If every transporter has been assigned but the solution is still not saturated, these algorithms do not find any saturating solution. However, as opposed to algorithm $\left(\mathrm{sGJ}\right)$, the found solution is still feasible for the unsaturated problem as long as the number of transporters is at least as large as the number of jobs, i.e., if the instance itself is feasible. Indeed, both algorithms $\left(\mathrm{sGR}c\right)$ and $\left(\mathrm{sGR}i\right)$ assign the first $N_J$ transporters to different jobs.

Recall that by Equation (1):

$$C(j,\underset{X}{¯}):=C^{\mathrm{sat}}\left(j\right)·\frac{L(j,\underset{X}{¯})}{L(j,\underset{X}{¯})-I(j,\underset{X}{¯})},$$

and by Equation (2):

$$L(j,\underset{X}{¯}):=max\left\{\sum _{r\in \mathcal{R}}\underset{X}{¯}{}_{r,j}·\kappa \left(r\right),\delta \left(j\right)+\underset{r\in \mathcal{R}}{max}\left[\underset{X}{¯}{}_{r,j}·\kappa \left(r\right)\right]\right\}.$$

Therefore, at every step of Algorithms $\left(\mathrm{sGR}c\right)$ and $\left(\mathrm{sGR}i\right)$, we only need to save the current values of the total and of the maximum assigned transporter capacities in order to decide where to assign the next transporter. We deduce from Equation (2) whether a job is saturated or not.

Theorem 4.

Algorithms $\left(\mathrm{sGR}c\right)$ and $\left(\mathrm{sGR}i\right)$ run in $O(N_R·log\left[N_R\right])$.

Proof. 

In both algorithms, we first sort the transporters by decreasing filling time in $O(N_R·log\left[N_R\right])$. Then, the two algorithms use a different strategy to select the best job to which the next transporter is assigned. For Algorithm $\left(\mathrm{sGR}i\right)$, the best job maximizes the idle time per period. For Algorithm $\left(\mathrm{sGR}c\right)$, the best job maximizes the completion time.

In either case, we sort the jobs in $O(N_J·log\left[N_J\right])$ using e.g., a heap map. Then, the algorithm extracts the best job in $O(log\left[N_J\right])$ time, update its value along with its total and its maximum transporter filling times in $O\left(1\right)$ time, and re-insert it into the heap in $O(log\left[N_J\right])$.

Since our problem requires $N_J\le N_R$, the time complexity of the algorithm is $O(N_R·log\left[N_R\right])$. □

6. The General Transporter Allocation Problem

In this section, we consider the general transporter allocation problem $\left(\mathrm{TAP}\right)$, where we allow jobs to have idle time.

In the first part of this section, we show how to exactly compute the frontier of Pareto optimal solutions for an instance of $\left(\mathrm{TAP}\right)$. In order to do this, we first consider how to minimize the makespan for a given set of transporters. Then, the Pareto frontier can be computed by iteratively increasing the number of transporters we are allowed to assign.

Then, in the second part of this section, we introduce heuristics to approximate the Pareto frontier instead.

All algorithms developed in this section are evaluated in Section 7.

6.1. Computing the Pareto Frontier Exactly

Now, we consider the problem of finding a solution of minimum makespan for a given instance of $\left(\mathrm{TAP}\right)$. Note that if only a subset of the given transporter set of size k should be used instead, it is the same as computing the minimum makespan for a new instance of $\left(\mathrm{TAP}\right)$ using only the k transporters with largest filling time. Observe also that a solution of minimum makespan does not necessarily use every transporter, as short jobs do not require to be saturated.

We first introduce a mixed integer quadratic program for which it is easy to see that it indeed finds a solution with minimum makespan for a feasible instance of $\left(\mathrm{TAP}\right)$. Then, we show how the quadratic program can be solved by instead iteratively solving a mixed integer linear program.

6.1.1. A Mixed Integer Quadratic Program

We denote by ${\mathbb{R}}^{+}$ the set of real positive numbers, including 0. The following mixed integer non-linear program computes a solution to $\left(\mathrm{TAP}\right)$ minimizing the makespan, using the return time $\delta \left(j\right)$, the saturated job processing time $C^{\mathrm{sat}}\left(j\right)$, the period length $\underset{L}{¯}{}_j$, and the idle time per period $\underset{I}{¯}{}_j$. Note that $\underset{L}{¯}$ and $\underset{I}{¯}$ in this case are used as variables, instead of the predefined values $L(j,\underset{X}{¯})$ and $I(j,\underset{X}{¯})$, as introduced in Section 1.

$$\begin{array}{ccc}\hfill \left(\mathrm{QTAP}\right):& \hfill & \hfill \end{array}$$

$$\begin{array}{ccc}\hfill \underset{\underset{X}{¯},C^{*},\underset{L}{¯},I}{min}& C^{*}\hfill & \end{array}$$

(17)

$$\begin{array}{ccc}\hfill \mathrm{s}.\mathrm{t}.& \sum _{j\in \mathcal{J}}\underset{X}{¯}{}_{r,j}\le 1,\hfill & \hfill \forall r\in \mathcal{R}\end{array}$$

(18)

$$\begin{array}{ccc}\hfill & \sum _{r\in \mathcal{R}}\underset{X}{¯}{}_{r,j}\ge 1,\hfill & \hfill \forall j\in \mathcal{J}\end{array}$$

(19)

$$\begin{array}{ccc}\hfill & C^{*}\ge C^{\mathrm{sat}}\left(j\right)·\frac{\underset{L}{¯}{}_j}{\underset{L}{¯}{}_j-\underset{I}{¯}{}_j}\hfill & \hfill \forall j\in j\end{array}$$

(20)

$$\begin{array}{ccc}\hfill & \underset{L}{¯}{}_j=\underset{I}{¯}{}_j+\sum _{r\in \mathcal{R}}\underset{X}{¯}{}_{r,j}·\kappa \left(r\right)\hfill & \hfill \forall j\in \mathcal{J}\end{array}$$

(21)

$$\begin{array}{ccc}\hfill & \underset{L}{¯}{}_j\ge \underset{X}{¯}{}_{r,j}·\kappa \left(r\right)+\delta \left(j\right)\hfill & \hfill \forall j\in \mathcal{J},\forall r\in \mathcal{R}\end{array}$$

(22)

$$\begin{array}{ccc}\hfill & \underset{X}{¯}{}_{r,j}\in \{0,1\},\hfill & \hfill \forall j\in \mathcal{J},\forall r\in \mathcal{R}\end{array}$$

(23)

$$\begin{array}{ccc}\hfill & \underset{L}{¯}{}_j,\underset{I}{¯}{}_j\in {\mathbb{R}}^{+},\hfill & \hfill \forall j\in \mathcal{J}\end{array}$$

(24)

Note that because of the terms $\frac{\underset{L}{¯}{}_j}{\underset{L}{¯}{}_j-\underset{I}{¯}{}_j}$ in Equation (20), the above program is indeed not linear. Namely, we get a quadratic program by multiplying both sides of the equation by $\underset{L}{¯}{}_j-\underset{I}{¯}{}_j$. In the next subsection, we will propose an alternative algorithm to solve $\left(\mathrm{TAP}\right)$ with the means of a slightly modified linear formulation.

Equation (17) ensures that $\underset{L}{¯}{}_j-\underset{I}{¯}{}_j>0$ (i.e., the idle time is finite); hence, Equation (20) does not induce a division by zero. Equation () computes the job completion time.

Equations (21) and (22) model the period length along with the idle time per period. For a given assignment $\underset{X}{¯}$, the value of $\underset{L}{¯}{}_j-\underset{I}{¯}{}_j$ is fixed by Equation (21). Since we minimize the makespan, the program will tend to minimize $\underset{L}{¯}{}_j$ by Equation (20) while keeping it above $\delta \left(j\right)+max\{\kappa \left(r\right):\underset{X}{¯}{}_{r,j}=1\}$ by Equation (22). However, in this mathematical program, $\underset{L}{¯}{}_j$ and $\underset{I}{¯}{}_j$ do not exactly model the period length and idle time per period, as defined in Equations (2) and (3). Indeed, a solution to $\left(\mathrm{QTAP}\right)$ may contain additional, unnecessary idle times for some jobs, and thus, the period length of those jobs may be artificially increased as long as the resulting completion time stays shorter than the completion time of the longest job. This problem could be fixed, though, by minimizing, for example, the average completion time as an additional objective.

6.1.2. Solving the Mixed Integer Quadratic Program

Instead of directly computing the optimal completion time of $C^{*}$, we iteratively look for a solution with a given completion time. We denote the maximum saturated job processing time by:

$$C_{max}^{\mathrm{sat}}:=\underset{j}{max}\left\{C^{\mathrm{sat}}\left(j\right)\right\}.$$

(25)

The makespan $C^{*}$ of any solution to $\left(\mathrm{TAP}\right)$ takes at least this duration:

$$C^{*}\ge C_{max}^{\mathrm{sat}}.$$

(26)

We define the rate of idle time per period $\rho (j,C)$ as the rate of idle time to have at every period for job j so that its completion time is C:

$$\rho (j,C):=1-\frac{C^{\mathrm{sat}}\left(j\right)}{C}<1.$$

(27)

Hence, we fix the idle time per period as:

$$\underset{I}{¯}{}_j=\rho (j,C)·\underset{L}{¯}{}_j.$$

(28)

The following mixed integer program $\left(\rho \mathrm{MIP}\right)$ minimizes the number of assigned transporters under the same constraints as in the above mathematical program after replacing the idle time variables and the job completion time variables:

$$\begin{array}{ccc}\hfill \left(\rho \mathrm{MIP}\right):& \hfill & \hfill \end{array}$$

$$\begin{array}{ccc}\hfill \underset{\underset{X}{¯}}{min}& \sum _{r\in \mathcal{R}}\sum _{j\in \mathcal{J}}\underset{X}{¯}{}_{r,j}\hfill & \end{array}$$

(29)

$$\begin{array}{ccc}\hfill \mathrm{s}.\mathrm{t}.& \sum _{j\in \mathcal{J}}\underset{X}{¯}{}_{r,j}\le 1,\hfill & \hfill \forall r\in \mathcal{R}\end{array}$$

(30)

$$\begin{array}{ccc}\hfill & \frac{{\sum }_{r^{\prime }}\left[\underset{X}{¯}{}_{j,r^{\prime }}·\kappa \left(r^{\prime }\right)\right]}{1-\rho (j,C)}-\underset{X}{¯}{}_{r,j}·\kappa \left(r\right)\ge \delta \left(j\right)\hfill & \hfill \forall j\in \mathcal{J},\forall r\in \mathcal{R}\end{array}$$

(31)

$$\begin{array}{ccc}\hfill & \underset{X}{¯}{}_{r,j}\in \{0,1\},\hfill & \hfill \forall j\in \mathcal{J},\forall r\in \mathcal{R}.\end{array}$$

(32)

Since $\rho (j,C)<1$, it follows that $\underset{I}{¯}{}_j<\underset{L}{¯}{}_j$ and hence Equation (19) is not needed anymore. Equation (31) is the combination of Equations (21) and (22) from the previous mathematical program along with the idle time per period formula of Equation (28). Note that it differs from the saturation condition of Equation (8) only by the factor $1/\left(1-\rho (j,C)\right)$.

Lemma 2.

For any solution of $\left(\rho \mathrm{MIP}\right)$, the completion time of every job is $C^{*}$.

Proof. 

Consider a solution $\underset{X}{¯}$ of $\left(\rho \mathrm{MIP}\right)$. For every job j, the idle time per period is:

$$\begin{array}{cc}\hfill \underset{I}{¯}{}_j& =\rho (j,C)·\underset{L}{¯}{}_j\hfill \\ \hfill & =(1-\frac{C^{\mathrm{sat}}\left(j\right)}{C^{*}})·\underset{L}{¯}{}_j\hfill \\ \hfill & =\underset{L}{¯}{}_j-\underset{L}{¯}{}_j·\frac{C^{\mathrm{sat}}\left(j\right)}{C^{*}}.\hfill \end{array}$$

Using Equation (1), the job completion time $C\left(j\right)$ is then:

$$\begin{array}{cc}\hfill C\left(j\right)& =C^{\mathrm{sat}}\left(j\right)·\frac{\underset{L}{¯}{}_j}{\underset{L}{¯}{}_j-\underset{I}{¯}{}_j}\hfill \\ \hfill & =C^{\mathrm{sat}}\left(j\right)·\underset{L}{¯}{}_j·\frac{C^{*}}{\underset{L}{¯}{}_j·C^{\mathrm{sat}}\left(j\right)}\hfill \\ \hfill & =C^{*}.\hfill \end{array}$$

□

Now, we show that for a given target makespan $C^{*}$, a solution to $\left(\rho \mathrm{MIP}\right)$ is a solution to $\left(\mathrm{TAP}\right)$, i.e., an element of the Pareto frontier. Furthermore, ignoring artificial idle times, a solution to $\left(\mathrm{TAP}\right)$ can be found by solving $\left(\rho \mathrm{MIP}\right)$ with an appropriate target makespan $C^{*}$.

Theorem 5.

For a given target makespan $C^{*}$, any solution of $\left(\rho \mathrm{MIP}\right)$ is a solution of $\left(\mathrm{TAP}\right)$ with makespan at most $C^{*}$. Conversely, any solution of $\left(\mathrm{TAP}\right)$ with makespan $C^{*}$ can be transformed into a solution of $\left(\rho \mathrm{MIP}\right)$ with target makespan $C^{*}$.

Proof. 

Algorithm $\left(\rho \mathrm{MIP}\right)$ has been constructed from $\left(\mathrm{QTAP}\right)$ by fixing the variables $\underset{I}{¯}$ and $\underset{L}{¯}$ for a given target makespan $C^{*}$. Therefore, any solution to $\left(\rho \mathrm{MIP}\right)$ is a solution to $\left(\mathrm{QTAP}\right)$ and therefore to $\left(\mathrm{TAP}\right)$. Moreover, by definition of $\left(\rho \mathrm{MIP}\right)$, the makespan of the any solution is at most $C^{*}$.

On the other hand, given a solution $\underset{X}{¯}$ of $\left(\mathrm{TAP}\right)$, we can increase the completion time of every job up to the makespan $C^{*}$. After adding such artificial idle times, note that the new solution $\underset{X}{¯}{}^{\prime }$ fulfills Equation (28) for all jobs. Therefore, it is also a solution of $\left(\rho \mathrm{MIP}\right)$ with target makespan $C^{*}$. □

Theorem 5 implies that in order to find a solution minimizing the makespan $C_{min}^{*}$ for $\left(Q\mathrm{TAP}\right)$ and therefore $\left(\mathrm{TAP}\right)$, we can instead run $\left(\rho \mathrm{MIP}\right)$ for different values of $C^{*}$ using a binary search. The following lemma limits the search interval for $C_{min}^{*}$.

Lemma 3.

The minimum makespan $C_{min}^{*}$ is between $C_{max}^{\mathrm{sat}}$ and the minimum makespan of any solution to the homogeneous transporter fleet problem where every transporter has filling time ${min}_r\left\{\kappa \left(r\right)\right\}$.

Proof. 

By definition, the completion time of a job $j\in \mathcal{J}$ cannot be smaller than its saturated processing time $C^{\mathrm{sat}}\left(j\right)$. On the other hand, given an assignment for the homogeneous transporter fleet problem, then increasing the values for $\kappa \left(j\right)$ while keeping the assignment the same does not increase the completion time of any job. □

Hence, we can use a binary search between these values to approximate an optimal solution. The following Lemma is straightforward.

Lemma 4.

Consider $\epsilon >0$, $C_1$ and $C_2\in [C_1,C_1+\epsilon ]$ such that $\left(\rho \mathrm{MIP}\right)$ has a solution for $C^{*}=C_2$ and no solution for $C^{*}=C_1$. Then, the solution for $C^{*}=C_2$ has a maximum job completion time at most ε away from the optimal solution of $\left(\mathrm{TAP}\right)$. Moreover, it minimizes the number of transporters used among the solutions with a makespan of $C_2$.

We denote by $\left(\mathrm{BS}\right)$ the above described binary search algorithm framework, which requires an inner algorithm to solve $\left(\rho \mathrm{MIP}\right)$. Note that we can aggregate $\left(\rho \mathrm{MIP}\right)$ by a transporter model similarly to $\left(s\mathrm{MIP}g\right)$.

6.1.3. Pareto Frontier

Now, instead of computing a single solution, we compute the Pareto frontier of a $\left(\mathrm{TAP}\right)$ instance. By construction, the assignment computed by Algorithm $\left(\mathrm{BS}\right)$ has minimum makespan $C_{min}^{*}$ and uses as few transporters as possible. The Pareto frontier of the assignments is as depicted in Figure 3.

The transporter count in a Pareto optimal solution is as least equal to the number of jobs and at most equal to the transporter count computed by Algorithm $\left(\mathrm{BS}\right)$.

Our main algorithm $(\mathrm{BS}.\mathrm{MIP}g)$ in this paper computes, for each transporter count, a solution with the minimum makespan using this number of transporters. This can be done with one binary search $\left(\mathrm{BS}\right)$ per transporter count. At every iteration, we solve an aggregated version of $\left(\rho \mathrm{MIP}\right)$ using an MIP solver. Note that when computing a Pareto solution for a given count of every transporter, we choose the transporters with the biggest capacity.

6.2. Heuristics to Compute the Pareto Frontier

Now, we introduce several different heuristic algorithms to approximate the Pareto frontier of a $\left(\mathrm{TAP}\right)$ instance.

First, we use simple extensions of the heuristics for the saturated problem to compute the Pareto frontier directly. Then, we show how to achieve alternative heuristics by combining the heuristics for the saturated problem directly with ideas from the first part to approximate solutions of minimum makespan for the general $\left(\mathrm{TAP}\right)$, given a fixed set of transporters. Then, as in the first part, an approximation of the Pareto frontier can be gained by iteratively increasing the number of transporters we are allowed to assign.

6.2.1. Extensions of the Saturated Algorithms

Now, we extend the saturated greedy algorithms $\left(\mathrm{sGJ}\right)$, $\left(\mathrm{sGR}i\right)$, and $\left(\mathrm{sGR}c\right)$ to compute a Pareto frontier for $\left(\mathrm{TAP}\right)$. Note that every solution of the Pareto frontier must assign at least one transporter to each job, as otherwise, the makespan is infinite.

It is straightforward to extend the greedy algorithms by transporter $\left(\mathrm{sGR}i\right)$ and $\left(\mathrm{sGR}c\right)$ to compute a Pareto frontier, since every iteration already provides a partial assignment using one more transporter. At every iteration, we generate a completed assignment by temporarily providing one transporter to each job that had not received any transporter yet. If we do not have enough transporters to complete the assignment, the algorithm stops and returns the computed Pareto frontier. We denote by $\left(\mathrm{GR}i\right)$ and $\left(\mathrm{GR}c\right)$ the extension of the greedy heuristics to the general case.

For the greedy algorithm by job $\left(\mathrm{sGJ}\right)$, there is no simple way of creating a Pareto frontier. Our extension $\left(\mathrm{GJ}\right)$ of algorithm $\left(\mathrm{sGJ}\right)$ iteratively runs with different transporter counts, always choosing the ones with biggest capacity. For a fixed transporter count, when assigning transporters to a job, $\left(\mathrm{GJ}\right)$ must restrict the maximum number of transporters assigned to this job such that the next jobs can still receive at least one transporter. Since Algorithm $\left(\mathrm{GJ}\right)$ allows jobs to not be saturated, it becomes more important to order the jobs in a meaningful sequence before assigning the transporters. We sort the jobs by decreasing values of completion time they would have if they were only assigned the smallest transporter. If we denote by ${\kappa }_{min}$ the minimum transporter filling time, by Equation (1), that means jobs are sorted by non-increasing value of $C^{\mathrm{sat}}\left(j\right)·\frac{\delta \left(j\right)+{\kappa }_{min}}{{\kappa }_{min}}$, depending on the job return time $\delta \left(j\right)$. In our simulations, we will only consider jobs with the same saturated processing time. In this case, our job order is equivalent to ordering the jobs by decreasing return times.

6.2.2. Binary Search Heuristics

In the following, we develop new heuristics by replacing the resolution of program $\left(\rho \mathrm{MIP}\right)$ with greedy heuristics in the binary search framework from $(\mathrm{BS}.\mathrm{MIP}g)$.

The program $\left(\rho \mathrm{MIP}\right)$ consists of minimizing the number of used transporters for a fixed makespan. Hence, Algorithm $(\mathrm{BS}.\mathrm{MIP}g)$ computes a solution, minimizing the number of used transporters for different makespan values. This is exactly what Algorithm $\left(\mathrm{GR}c\right)$ does. Therefore, combining this algorithm with a binary search will not yield any better result.

On the other hand, Algorithms $\left(\mathrm{sGJ}\right)$ and $\left(\mathrm{GR}i\right)$ focus on the idle time per period. The former looks for a combination of transporters saturating a job, while the latter aims at minimizing the maximum idle time per period. In the following, we slightly modify program $\left(\rho \mathrm{MIP}\right)$ to look like an instance to $\left(s\mathrm{TAP}\right)$ and use our greedy algorithms.

The program $\left(\rho \mathrm{MIP}\right)$ only differs from a saturated transporter allocation program by the factor $1/\left(1-\rho (j,C)\right)$ in Equation (31). Namely, for every job j:

$$\frac{1}{1-\rho (j,C)}·\sum _r\left[\underset{X}{¯}{}_{r,j}·\kappa \left(r\right)\right]-\underset{r}{max}\left[\underset{X}{¯}{}_{r,j}·\kappa \left(r\right)\right]\ge \delta \left(j\right).$$

We rewrite Equations (31) as:

$$\begin{array}{cc}\hfill \sum _r\left[\underset{X}{¯}{}_{r,j}·\kappa \left(r\right)\right]-\left[1-\rho (j,C)\right]·\underset{r}{max}& \left[\underset{X}{¯}{}_{r,j}·\kappa \left(r\right)\right]\ge \left[1-\rho (j,C)\right]·\delta \left(j\right)\hfill \\ \hfill \sum _r\left[\underset{X}{¯}{}_{r,j}·\kappa \left(r\right)\right]-\underset{r}{max}\left[\underset{X}{¯}{}_{r,j}·\kappa \left(r\right)\right]\ge & \left[1-\rho (j,C)\right]·\delta \left(j\right)\hfill \\ \hfill & -\rho (j,C)·\underset{r}{max}\left[\underset{X}{¯}{}_{r,j}·\kappa \left(r\right)\right].\hfill \end{array}$$

Since the maximum capacity assigned to a job is bounded by the maximum capacity over all transporters ${\kappa }_{max}$, the following constraint is more restrictive:

$$\sum _r\left[\underset{X}{¯}{}_{r,j}·\kappa \left(r\right)\right]-\underset{r}{max}\left[\underset{X}{¯}{}_{r,j}·\kappa \left(r\right)\right]\ge \left[1-\rho (j,C)\right]·\delta \left(j\right)-\rho (j,C)·{\kappa }_{max}.$$

(33)

This more restrictive constraint corresponds to a modified instance of $\left(\mathrm{sTAP}\right)$, with a return time of $\left[1-\rho (j,C)\right]·\delta \left(j\right)-\rho (j,C)·{\kappa }_{max}$ instead of $\delta \left(j\right)$ for job j. We call $\left(r\mathrm{MIP}\right)$ the mixed integer program obtained by replacing Equation (31) with Equations (33), modeling a saturated transporter assignment problem.

We can use this modified framework with any of our greedy heuristics to approximate the Pareto frontier. We denote by $(\mathrm{BS}.\mathrm{GJ})$ and $(\mathrm{BS}.\mathrm{GR}i)$ the binary search-based heuristics using Algorithms $\left(\mathrm{sGJ}\right)$ and $\left(\mathrm{sGR}i\right)$ respectively to solve $\left(r\mathrm{MIP}\right)$.

7. Experiments

In this section, we provide two series of experiments. Firstly, we analyze the computation time and the efficiency of the saturated algorithms, which are the core of our algorithms. Afterward, we take a look at the Pareto frontiers computed for the general problem.

7.1. Simulation Environment

The simulations are done on a ThinkPad T490s with a processor Intel Core i7-8665U with 1.90GHz. Algorithms are implemented under Windows 10 in C#, and we use the open-source library Google-OR-Tools to solve mixed integer programs.

For the sake of simplicity, we restrict our simulations to a limited case study. We evaluate the performance of the algorithms on 100 feasible instances with a limited transporter fleet, using the following scenarios:

• 4 jobs, 20 transporters;
• 5 jobs, 25 transporters;
• 6 jobs, 30 transporters;
• 7 jobs, 35 transporters.

We randomly generate 100 problem instances for each scenario. The number of jobs, number of transporters, as well as the job return times and the transporter filling times are all integers following an uniform distribution. The return time of every job is between 5 and 15, and the filling time of every transporter is between 1 and 5. Therefore, every job will need on average $1+\lceil \frac{5+15}{1+5}\rceil =5$ transporters. Every job has the same saturated processing time of 180.

We are interested in three criteria:

1

The average computation time of the algorithm.

2

The number of infeasible instances, where the algorithm did not find an assignment.

3

The number of assigned transporters. Whenever the model is infeasible, we set the number of assigned transporters equal to the total number of transporters. Thus, we choose for this criterion to not penalize infeasible instances compared to a feasible assignment effectively using every transporter at our disposal.

Each of these criteria is sought to be minimized: a good performing algorithm must have low values for these criteria. Note that for saturated algorithms, the completion time of every job is fixed; hence, it does not need to be evaluated.

7.2. Performance of the Saturated Algorithms

We consider the following saturating algorithms:

• Algorithm $\left(\mathrm{sGJ}\right)$, assigning transporters to jobs one by one.
• Algorithms $\left(\mathrm{sGR}i\right)$ and $\left(\mathrm{sGR}c\right)$, iteratively assigning transporters to the job with maximum idle time per period and maximum completion time, respectively.
• Algorithm $\left(\mathrm{sMIP}g\right)$, the mixed integer program grouping transporters with equal filling time.

We excluded the simple mixed integer program $\left(\mathrm{sMIP}\right)$, as it turned out that it is already too slow for our problem instances (see Figure 4).

Figure 5 presents the running times of the algorithms. Algorithm $\left(\mathrm{sMIP}g\right)$ is reasonably fast for our small problem instances of up to 10 jobs. All greedy heuristics always run in a few milliseconds. We remind here that the complexity of Algorithm $\left(\mathrm{sGJ}\right)$ is exponential in the saturating transporter cardinality, which should not exceed six in our test sets.

Figure 6 and Figure 7 show for every algorithm the total number of infeasible instances and the average number of used transporters, respectively. Since our test sets only contain feasible instances, the optimal algorithm $\left(\mathrm{sMIP}g\right)$ has no infeasible instance. Among the greedy heuristics, the heuristic by job $\left(\mathrm{sGJ}\right)$ performs better than the heuristics by transporters. This is an intuitive result in saturated scenarios, as $\left(\mathrm{sGJ}\right)$ looks for the tightest assignment for every job, whereas Algorithms $\left(\mathrm{sGR}i\right)$ and $\left(\mathrm{sGR}c\right)$ assign transporters on the fly, without ensuring that the transporters assigned to a same job fit well together. Algorithm $\left(\mathrm{sGR}c\right)$, which minimizes the completion time at every step, performs slightly worse than Algorithm $\left(\mathrm{sGR}i\right)$, which minimizes the idle time at every step, for a similar reason: since the objective is to remove the idle time, it is more beneficial to focus on the idle time than the completion time, as the latter also depends on the superfluous total size of the job.

We conclude that when looking for a saturated solution, a good recommendation is to use the greedy heuristic by jobs $\left(\mathrm{sGJ}\right)$.

7.3. Performance of the General Algorithms

We now evaluate the Pareto frontier generated by the following algorithms:

• The three greedy algorithms $\left(\mathrm{GJ}\right)$, $\left(\mathrm{GR}i\right)$, and $\left(\mathrm{GR}c\right)$ generalizing their saturated counterparts $\left(\mathrm{sGJ}\right)$, $\left(\mathrm{sGR}i\right)$, and $\left(\mathrm{sGR}c\right)$.
• The binary search algorithm $(\mathrm{BS}.\mathrm{MIP}g)$ solving an aggregated version of $\left(\rho \mathrm{MIP}\right)$ by grouping transporters with equal filling time.
• The binary search heuristics $(\mathrm{BS}.\mathrm{GJ})$ and $(\mathrm{BS}.\mathrm{GR}i)$, which are iteratively called respectively $\left(\mathrm{sGJ}\right)$ and $\left(\mathrm{sGR}i\right)$ to solve the saturated mixed integer program $\left(r\mathrm{MIP}\right)$ with altered job return times.

Figure 8 shows the computed Pareto frontiers for our first simulation scenario, using $four$ jobs and 20 transporters. Contrary to the saturated case, Algorithm $\left(\mathrm{GJ}\right)$ performs poorly for limited transporter fleets, as it over-invests transporters for the first jobs while letting future jobs have a single transporter. Since the last job typically gets assigned the smallest transporter in the fleet, adding an even smaller transporter to the fleet will further increase its completion time, hence potentially increasing the makespan of the assignment. In other words, Algorithm $\left(\mathrm{GJ}\right)$ may generate a worse, dominated solution while using a bigger transporter fleet. In order to create a non-increasing Pareto frontier, we set the makespan with N available transporters as the minimum makespan over every instance using at most N transporters.

Algorithm $\left(\mathrm{GR}i\right)$ is less efficient than Algorithm $\left(\mathrm{GR}c\right)$ for a similar reason: since we want to minimize the maximum job completion time, we should assign more transporters to jobs with the highest residual completion time instead of the job with the highest residual idle time.

However, the binary search-based heuristics generally perform very well when compared to the nearly optimal algorithm $(\mathrm{BS}.\mathrm{MIP}g)$, with the exception of $(\mathrm{BS}.\mathrm{GJ})$ when using less than 10 transporters. This shows that virtually increasing the return times of the small jobs (with short saturated processing time) is a good way to balance the transporter fleet between the jobs and ensure a short makespan. Note that the Pareto frontiers generated by the binary search heuristics only start at eight transporters, because each job needs at least two transporters to be saturated.

Finally,

Table 2. Average running times to compute the Pareto frontiers over 100 instances, in seconds.

Algorithm	$(\mathrm{BS}.\mathrm{MIP}g)$	$\left(\mathrm{GJ}\right)$	$\left(\mathrm{GR}i\right)$	$\left(\mathrm{GR}c\right)$	$(\mathrm{BS}.\mathrm{GJ})$	$(\mathrm{BS}.\mathrm{GR}i)$
Runtimes [s]	33	0.00075	0.00011	0.00015	0.013	0.010

shows that the binary search-based heuristics are extremely fast, despite being 10 to 100 times slower than their greedy counterpart.

We conclude that to solve an instance of the transporter assignment problem, an efficient method consists of iteratively increasing the return time of the jobs until the problem has a saturated solution. Then, the computed saturated solution is a good solution to the initial assignment problem. An advantage of this method is that the saturated problem instances do not have to be solved to optimality, and most decent algorithms should induce a good solution to the transporter assignment problem.

8. Conclusions

The objective of the transporter allocation problem is to assign transporters to jobs to jointly minimize the makespan of the jobs and the number of assigned transporters. Crucially, transporters have a limited capacity, and usually, multiple transporters are assigned to a single job. After processing a share of the job load, a transporter must wait for a given time before it can process the job again. In particular, the goal is to compute the frontier of Pareto optimal solutions.

To the best of our knowledge, this is the first study on the assignment of an heterogeneous transporter fleet where transporters are regarded as a dynamic resource impacting the completion times and not as a fixed requirement.

We show that in general, it is NP-hard in the strong sense to compute even a single point on the Pareto frontier. In particular, it is NP-complete to decide whether a solution exists where every job has the same minimum completion time. Furthermore, the problem remains NP-hard in the usual sense, even if there are only two jobs.

On the other hand, when every transporter is identical, the whole Pareto frontier can be computed in a runtime polynomial in the number of jobs and transporters.

We provide several exact algorithms and heuristics to compute the minimum number of transporters needed such that all jobs are contracted to their minimum completion time. Then, we use these results to compute Pareto frontiers for general $\left(\mathrm{TAP}\right)$ instances, both exactly and heuristically. Computational experiments show that our heuristics compute quickly decent approximations of the optimal solution, where the mixed integer program is already slow.

The results presented in this paper are part of a wider, practical study, in which we used a multi-level approach to solve applied problems in farming logistics together with an industrial partner. Assigning transporters to jobs was one of several levels of decision making in this regard, and our algorithms (adjusted for some additional practical needs) have proven to be useful also in early applied experiments.

In this paper, we assumed that every team of transporters only completes a single job. However, depending on the job sizes, there are also a variety of practical applications, where transporters are grouped into teams to fulfill several jobs per day in a sequence. Removing this limitation in a future study would significantly increase the number of use cases to which our results can be applied. Note that moving from one job to another may induce location-dependent traveling times, which we did not need to take into account in this paper. Even though we expect a single move from one job (or from the hub) to the next job to only have a minor impact on the solution, it will be important to find the best time to switch a transporter from one job to the next. Another challenge would be how to decide which jobs should be served by the same transporter team and which should receive a different team. Such a clustering, if not mandated by practical circumstances such as large travel times between the jobs, would be an additional degree of freedom, which can have a large impact on the optimality of a solution.

As a further area of extension, note that in our model, it is implicitly assumed that all teams of transporters are disjointed (since each transporter can only be assigned to one job). This is common practice to simplify the planning task, but it can lead to less efficient solutions. In some applications, such as [2,4], transporters are allowed to alternate between different jobs, optimizing the usage of each machine and hence providing better solutions. Allowing this for our problem would add an additional layer of difficulty. In particular, period lengths would no longer be constant but would differ, depending on when some transporters may serve another job. The scheduling decision, when to switch transporters to another job, would be much more impactful, and the scheduling of transporters to process each job would most likely have to be dealt with explicitly in that case.