Solution algorithms for unrelated machines minmax regret scheduling problem with interval processing times and the total flow time criterion

Abstract

An uncertain version of the task scheduling problem on unrelated machines to minimize the total flow time is considered. It is assumed that processing times are not known a priori, but they belong to intervals of known bounds. The absolute regret is applied to evaluate the uncertainty, and minmax regret task scheduling problem is solved. A simple 2-approximate middle intervals time efficient algorithm is proposed. More time consuming but better in terms of the quality of solutions scatter search based heuristic algorithm is described. Its usefulness is justified via computational experiments.

1 Introduction

The $R\Vert \sum C_j$ is a classical polynomially solvable scheduling problem (Bruno et al. 1974; Horn 1973). It consists in scheduling the set of n tasks on m parallel and unrelated machines, which means that machines can perform tasks at different speeds. Each machine can perform jth task $(j=1,\ldots,n)$ at different speed. The execution times $p_{ij}, i=1,\ldots,m;\;j=1,\ldots,n$ are given. The optimal schedule minimizes the total flow time ∑ _j C _j , i.e. the sum of task completion times where C _j is the completion time of jth task. In order to find the solution schedule, it is required to assign tasks to machines as well as to order the tasks on each machine.

In this paper we focus on the uncertain version of $R\Vert \sum C_j$ where the execution times of tasks are imprecise. We model the uncertainty by the concept of a scenario which corresponds to an assignment of plausible values to the imprecise parameters of the problem (Aissi et al. 2009). There exist different methods describing the set of possible scenarios. Two of them are the most popular: the discrete scenario case where the possible values of uncertain parameters are presented explicitly and the interval scenario case where the unknown parameters can take any value between lower and upper bounds. Hereinafter we consider the interval case, i.e. we assume that for each task only the bounds of intervals $\underline{p}_{ij}$ and $\overline{p}_{ij}$ are given where $\underline{p}_{ij}\leqslant\overline{p}_{ij}$ and ${p}_{ij}\in\left[\underline{p}_{ij},\overline{p}_{ij}\right].$ Such a way of uncertainty description is useful in problems where there is no historical data regarding the imprecise parameters, which would be required in order to obtain the probability distribution and apply the stochastic approach, as well as when there are no experts’ opinions which would be a source of other representations of uncertain parameters p _ij , e.g. in the form of membership functions for the fuzzy approach.

The evaluation of the uncertainty is the second issue which has to be taken into account when solving uncertain versions of optimization problems. The majority of approaches proposed in the literature are based on the aggregation (determinization) of a criterion for the deterministic version. Minmax optimization problems are popular examples of this approach, for example (Aissi et al. 2009). The aggregation can concern also expressions based on the criterion. It allows us to determine less conservative solutions, for example (Aissi et al. 2009; Kouvelis and Yu 1997). Absolute regret or equivalently absolute opportunity loss, hereafter referred to as regret, is an example of such expression. It is defined for every schedule (solution) and every scenario as the difference between current and optimal values of the criterion (Savage 1951). The determinization is understood as taking for any schedule the value of regret maximum with respect to all possible scenarios. The resulting criterion undergoes the minimization for all feasible schedules. Such an approach is called minmax regret, for example (Averbakh 2010; Kouvelis and Yu 1997) and can be additionally treated as the concept which consists in finding for any possible scenario a $\epsilon$-optimal schedule with $\epsilon$ as small as possible (Aissi et al. 2009). The same approach was used in (Kasperski and Zielinski 2008) for the uncertain $1\Vert \sum C_j.$ This paper generalizes the result presented there for any number of machines. The uncertain $1\Vert \sum C_j$ was also considered in (Montemanni 2007) where MIP approach was applied as the solution tool.

Minmax regret versions of many classical optimization problems such as shortest path, assignment, s–t cut and knapsack were studied, for example in (Aissi et al. 2009) and (Kasperski 2008). New results recently obtained are presented in (Averbakh and Pereira 2011; Kasperski and Zielinski 2010, 2011; Siepak and Jozefczyk 2011, 2013; Volgenant and Duin 2010), where the solution algorithms are proposed for the uncertain bottleneck, spanning tree and selected task scheduling problems.

The paper is organized as follows. The deterministic and uncertain versions of the considered problem are formulated in Sect. 2 The 2-approximate and heuristic solution algorithms are presented in Sect. 3 The population based scatter search (SS) heuristic algorithm was introduced for the first time in (Siepak and Jozefczyk 2013) where it was also used for solving other task scheduling problems. In this paper, it is additionally compared to a simple local search heuristic. Section 4 is devoted to the description of the computational experiments and their results. Conclusions complete the paper.

2 Problem formulation

2.1 Deterministic case

Let us introduce the following notation:

${\user2{J}}=\left\{1,2,\ldots,j,\ldots,n\right\}$—set of tasks,

${\user2{M}}=\left\{1,2,\ldots,i,\ldots,m\right\}$—set of machines,

$p=\left[p_{ij}\right]_{i=1,\ldots,m;j=1,\ldots,n}$—matrix of task execution times.

Let $x=\left[x_{ikj}\right]_{i=1,\ldots,m;j,k=1,\ldots,n}$ be a matrix of binary decision variables where x _ikj  = 1 if jth task is scheduled as kth to the last task on machine i, and 0, otherwise.

The objective function is defined as follows:

$$ F(p,x)=\sum_{i=1}^{m} \sum_{j=1}^{n} \sum_{k=1}^{n} kp_{ij}x_{ikj}. $$

(1)

The following constraints are imposed on decision variables x _ikj :

$$ \sum_{i=1}^{m} \sum_{k=1}^{n} x_{ikj}=1; \quad j=1,\ldots,n, $$

(2)

$$ \sum_{j=1}^{n} x_{ikj} \leqslant 1; \quad i=1,\ldots,m; \quad k=1,\ldots,n, $$

(3)

$$ x_{ikj} \in \left\{0,1\right\}, \quad i=1,\ldots,m; \quad j,k=1,\ldots,n. $$

(4)

Constraints (2) ensure that each task has to be performed on exactly one position of some machine. According to constraints (3), each position of every machine can be occupied by at most one task. Constraints (4) guarantee the binary form of matrix x which represents the schedule for the problem considered. In a consequence, the formulation of the deterministic version of $R\Vert \sum C_j$ is as follows:

$$ F{'}(p) \triangleq F(p,x{'}) = \min_{x}F(p,x) = \min_{x} \sum_{i=1}^{m} \sum_{j=1}^{n} \sum_{k=1}^{n} kp_{ij}x_{ikj} $$

(5)

where x′ is the optimal solution reflecting the optimal schedule subject to (2), (3) and (4). The above formulation corresponds to the assignment problem with n jobs and mn positions (Pinedo 2008).

2.2 Uncertain case

For the uncertain case, we assume that p _ij are not crisp, i.e. they belong to intervals $\left[\underline{p}_{ij},\overline{p}_{ij}\right]$ where $\underline{p}_{ij}$ and $\overline{p}_{ij}$ are known. It means that we consider the uncertain parameters p _ij described by a set of their possible values in the form of intervals. No other characteristics of such an uncertainty are assumed or used. A particular fixed configuration of the execution times is called a scenario. A set

$$ P=\left[\underline{p}_{11},\overline{p}_{11}\right]\times\ldots\times\left[\underline{p}_{mn},\overline{p}_{mn}\right] $$

(6)

of all scenarios is the Cartesian product of all intervals. The scenario under which the completion times of all tasks are equal to the bounds of the corresponding intervals $\underline{p}_{ij}$ or $\overline{p}_{ij}$ is called an extreme scenario.

In order to evaluate the quality of decision for the uncertain problem, we apply the regret criterion introduced by Savage in (Savage 1951). It denotes the difference between the value of the total flow time criterion for the given solution x and specified scenario p as well as the optimal value of the total flow time criterion for p:

$$ F\left(p,x\right)-F{'}\left(p\right). $$

(7)

Then the robust approach is used for the determinization of (7) with respect to all feasible scenarios, (Aissi et al. 2009; Kouvelis and Yu 1997), i.e.

$$ z(x)=\max_{p\in P}\left[F\left(p,x\right)-F{'}\left(p\right)\right]=F\left(p^{x},x\right)-F{'}\left(p^{x}\right) $$

(8)

where p ^x is called a worst case scenario. The optimal solution x* for the minmax regret version of $R\Vert \sum C_j$ minimizes (8), i.e. $z^* \,\triangleq\, z(x^*)=\min_{x}z(x)$ subject to (2), (3) and (4).

Some results concerning the time complexity of our problem as well as of related ones can be found in the literature. The strong NP-hardness of our problem has been shown in (Conde 2013) when the number of machines is a part of input (it has been assumed that m = n). The reduction from the strong NP-hard minmax regret assignment problem established in (Aissi et al. 2005) has been applied in the proof. In (Lebedev and Averbakh 2006) the NP-hardness of the minmax regret version of $1\Vert \sum C_j,$ i.e. for m = 1 has been justified, so our problem is at least NP-hard.

3 Solution algorithms

The deterministic version of $R\Vert \sum C_j$ is equivalent to the assignment problem where n tasks are to be assigned to mn positions (Pinedo 2008). Each machine has n positions where tasks can be assigned. This problem can be solved effectively with the application of the Hungarian algorithm which has polynomial complexity $O(\left(mn\right)^3)$ (Jungnickel 2008).

3.1 2-Approximation algorithm

In this section we extend the results presented in (Kasperski and Zielinski 2008). The authors proved there that in order to obtain 2-approximate solution for the minmax regret version of $1\Vert \sum C_j$ with interval execution times, it is enough to take into consideration the middles of the corresponding intervals. We show that the minmax regret version of $R\Vert \sum C_j$ has the same property.

Let us notice first that for two feasible solutions x and y the following equality holds:

$$ \begin{aligned} F(p,x)-F(p,y) &= \sum_{i=1}^{m} \sum_{j=1}^{n} \sum_{k=1}^{n} kp_{ij}x_{ikj} - \sum_{i=1}^{m} \sum_{j=1}^{n} \sum_{k=1}^{n} kp_{ij}y_{ikj}\\ &=\sum_{i=1}^{m} \sum_{j=1}^{n} p_{ij}\left(k_{ij}^{x}-k_{ij}^{y}\right) \end{aligned} $$

(9)

where for x and y k ^x _ij and k ^y _ij equal indices of positions to the last when task j is performed on machine i or 0, otherwise.

As a result of (9), we obtain:

$$ z(x) \geqslant \sum_{i,j:k_{ij}^x \leqslant k_{ij}^{y}} \underline{p}_{ij}\left(k_{ij}^{x}-k_{ij}^{y}\right) + \sum_{i,j:k_{ij}^x > k_{ij}^{y}} \overline{p}_{ij}\left(k_{ij}^{x}-k_{ij}^{y}\right). $$

(10)

Let p ^mid be the scenario where execution times of tasks equal middles of the corresponding intervals, i.e.

$$ p_{ij}^{\rm mid}=0.5 \left(\underline{p}_{ij}+\overline{p}_{ij}\right), \quad i=1,\ldots,m; \quad j=1,\ldots,n, $$

(11)

and x″ be the optimal solution of the deterministic problem for p ^mid. The theorem below is the basis for 2-approximation algorithm:

Theorem 1

The following inequality holds for the optimal solution x* of the minmax regret version of $R\Vert \sum C_j$:

$$ z(x{^{\prime\prime}}) \leqslant 2z\left(x^{*}\right). $$

(12)

Proof

Let us notice that, based on (9) for the scenario p ^mid and the solutions x*,  x″ introduced above, we obtain:

$$ F(p^{\rm mid},x^{*})-F(p^{\rm mid},x^{{^{\prime\prime}}})=0.5\sum_{i=1}^{m} \sum_{j=1}^{n} \left(\underline{p}_{ij}+\overline{p}_{ij}\right)\left(k_{ij}^{x^{*}}-k_{ij}^{x^{{^{\prime\prime}}}}\right) \geqslant 0, $$

(13)

and

$$ \begin{aligned} &\sum_{i,j:k_{ij}^{x^{*}}>k_{ij}^{x^{{^{\prime\prime}}}}}\underline{p}_{ij}\left(k_{ij}^{x^{*}}-k_{ij}^{x^{{^{\prime\prime}}}}\right) + \sum_{i,j:k_{ij}^{x^{*}}\leqslant k_{ij}^{x^{{^{\prime\prime}}}}}\underline{p}_{ij}\left(k_{ij}^{x^{*}}-k_{ij}^{x^{{^{\prime\prime}}}}\right)\\ &+ \sum_{i,j:k_{ij}^{x^{*}}>k_{ij}^{x^{{^{\prime\prime}}}}}\overline{p}_{ij}\left(k_{ij}^{x^{*}}-k_{ij}^{x^{{^{\prime\prime}}}}\right) + \sum_{i,j:k_{ij}^{x^{*}}\leqslant k_{ij}^{x^{{^{\prime\prime}}}}}\overline{p}_{ij}\left(k_{ij}^{x^{*}}-k_{ij}^{x^{{^{\prime\prime}}}}\right) \geqslant 0. \end{aligned} $$

(14)

From (14) it results immediately that:

$$ \begin{aligned} \sum_{i,j:k_{ij}^{x^{*}}\leqslant k_{ij}^{x^{{^{\prime\prime}}}}}\underline{p}_{ij}\left(k_{ij}^{x^{*}}-k_{ij}^{x^{{^{\prime\prime}}}}\right) + \sum_{i,j:k_{ij}^{x^{*}}>k_{ij}^{x^{{^{\prime\prime}}}}}\overline{p}_{ij}\left(k_{ij}^{x^{*}}-k_{ij}^{x^{{^{\prime\prime}}}}\right)\\ \geqslant \sum_{i,j:k_{ij}^{x^{*}}>k_{ij}^{x^{{^{\prime\prime}}}}}\underline{p}_{ij}\left(k_{ij}^{x^{{^{\prime\prime}}}}-k_{ij}^{x^{*}}\right) + \sum_{i,j:k_{ij}^{x^{*}}\leqslant k_{ij}^{x^{{^{\prime\prime}}}}}\overline{p}_{ij}\left(k_{ij}^{x^{{^{\prime\prime}}}}-k_{ij}^{x^{*}}\right). \end{aligned} $$

(15)

Taking into consideration (10) and (15) for solutions x*, x″, we have:

$$ z(x^{*}) \geqslant \sum_{i,j:k_{ij}^{x^{*}}>k_{ij}^{x^{{^{\prime\prime}}}}}\underline{p}_{ij}\left(k_{ij}^{x^{{^{\prime\prime}}}}-k_{ij}^{x^{*}}\right) + \sum_{i,j:k_{ij}^{x^{*}}\leqslant k_{ij}^{x^{{^{\prime\prime}}}}}\overline{p}_{ij}\left(k_{ij}^{x^{{^{\prime\prime}}}}-k_{ij}^{x^{*}}\right). $$

(16)

Let us notice now that for any feasible solutions x and y:

$$ z(y) \leqslant z(x) + \sum_{i,j:k_{ij}^{x}>k_{ij}^{y}}\underline{p}_{ij}\left(k_{ij}^{y}-k_{ij}^{x}\right) + \sum_{i,j:k_{ij}^{x} \leqslant k_{ij}^{y}}\overline{p}_{ij}\left(k_{ij}^{y}-k_{ij}^{x}\right). $$

(17)

The proof of (17) is analogous to the one presented in (Kasperski and Zielinski 2008). In order to prove Theorem 1, it is enough to insert (16) into (17) for solutions x* and x″, that gives:

$$ z(x^{{^{\prime\prime}}}) \leqslant z(x^{*}) + z(x^{*}) = 2z(x^{*}). $$

(18)

$\square$

The property proven leads to the following two step 2-approximate algorithm (MI) for the minmax regret version of $R\Vert \sum C_j$:

• 1. Specify scenario p ^mid consisting of the middles of the corresponding interval task execution times.

• 2. Find the solution x″ by solving $R\Vert \sum C_j$ under scenario p ^mid.

The following example illustrates the case when the above 2-approximation algorithm returns the solution exactly twice worse than the optimal one. Let us consider a problem of scheduling 3 tasks on 2 machines. The interval execution times are: $p_{11}=\left[3, 3\right]; \,p_{21}=\left[3, 3\right];$ $p_{12}=\left[1, 3\right]; \,p_{22}=\left[2, 2\right];$ $p_{13}=\left[2, 2\right]; \,p_{23}=\left[2, 5\right].$ For this instance of the problem, the simple computation shows that z(x′′) = 2 and z(x*) = 1.

3.2 Characterization of the worst case scenario

In this section we show how to compute the worst case scenario p ^x and the maximal regret z(x) of a given solution x. Let us notice that while considering (9) the regret can be expressed by the following equation:

$$ \begin{aligned} z(x) &= \max_{p \in P_{e}}\left[F(p,x)-F^{\prime}(p)\right] = F(p^{x},x)-F^{\prime}(p^{x})\\ &= \sum_{i=1}^{m} \sum_{j=1}^{n} \sum_{k=1}^{n} \left(kp_{ij}^{x}x_{ikj}-kp_{ij}^{x}x_{ikj}^{\prime}\right). \end{aligned} $$

(19)

For any solution y, let k ^y _j and i ^y _j denote respectively the index of position to the last and the machine on which task j is scheduled, i.e. y ^y _{i_j} k ^y _j j = 1. Therefore, the regret can be rewritten in the following form:

$$ z(x) = \sum_{j=1}^{n} \left(k_{j}^{x} p_{i_{j}^{x}j}^{x} - k_{j}^{x^{\prime}} p_{i_{j}^{x^{\prime}}j}^{x}\right) $$

(20)

where k ^x _j and i ^x _j are known for a given solution x. It is easy to see that if $i_{j}^{x} \ne i_{j}^{{x^{\prime}}},$ then we can increase the processing time p ^x _{i_j} j ^x to $\overline{p}_{i_{j}^{x}j}$ and decrease $p_{{i_{j}^{{x^{\prime}}} j}}^{x}$ to $\underline{p}_{i_{j}^{x^{'}}j}.$ Otherwise, i.e. for $i_{j}^{x} = i_{j}^{{x^{\prime}}}$, the execution time of task j depends on the indexes of positions to the last where it is scheduled on x and on x', i.e. $p_{i_{j}^{x}j}^{x} = p_{i_{j}^{x^{'}}j}^{x} = \overline{p}_{i_{j}^{x}j}$ if $k_{j}^{x} = k_{j}^{{x^{\prime}}}$ and $p_{i_{j}^{x}j}^{x} = p_{i_{j}^{x^{'}}j}^{x} = \underline{p}_{i_{j}^{x}j}$ if $k_{i}^{x} = k_{i}^{{x^{\prime}}} .$ Consequently, we can now express the regret of x as:

$$ \begin{aligned} z(x) &= \sum_{\left\{j: i_{j}^{x} \neq i_{j}^{x^{\prime}}\right\}} \left(k_{j}^{x} \overline{p}_{i_{j}^{x}j} - k_{j}^{x^{\prime}} \underline{p}_{i_{j}^{x^{\prime}}j}\right)\\ &+ \sum_{\left\{j: i_{j}^{x} = i_{j}^{x^{\prime}} \wedge k_{j}^{x} > k_{j}^{x^{'}}\right\}} \left(k_{j}^{x} \overline{p}_{i_{j}^{x}j} - k_{j}^{x^{'}} \overline{p}_{i_{j}^{x^{\prime}}j}\right)\\ &+ \sum_{\left\{j: i_{j}^{x} = i_{j}^{x^{\prime}} \wedge k_{j}^{x} \leq k_{j}^{x^{\prime}}\right\}} \left(k_{j}^{x} \underline{p}_{i_{j}^{x}j} - k_{j}^{x^{\prime}} \underline{p}_{i_{j}^{x^{\prime}}j}\right). \end{aligned} $$

(21)

Observe that the worst case scenario can be immediately obtained from (21) if we know x′, which as a result would allow us to know $k_{j}^{{x}^{\prime}}$ and $i_{j}^{{x}^{\prime}}.$ Moreover, the computation of x′ can be done by solving an assignment problem.

Let us define binary variables $z_{ikj} \in \left\{0,1\right\},$ $i = 1,\ldots,m;\;j,k=1,\ldots,n,$ where z _ikj takes 1 only if $k = k_{j}^{{x^{\prime}}}$ and $i = i_{j}^{{x^{\prime}}},$ that is task j is scheduled as the kth to the last on machine i in solution x′. Since each task has to be scheduled on exactly one position of exactly one machine, and each position on each machine is occupied by at most one job, the variables z _ikj fulfill the following requirements

$$ \sum_{i=1}^{m} \sum_{k=1}^{n} z_{ikj}=1; \quad j=1,\ldots,n, $$

(22)

$$ \sum_{j=1}^{n} z_{ikj} \leqslant 1; \quad i=1,\ldots,m; \quad k=1,\ldots,n, $$

(23)

$$ z_{ikj} \in \left\{0,1\right\}, \quad i=1,\ldots,m; \quad j,k=1,\ldots,n. $$

(24)

Regret (21) can be now expressed as:

$$ z(x) = \max_{z_{ikj}}{\sum_{i=1}^{m} \sum_{j=1}^{n} \sum_{k=1}^{n} \left(k_{j}^{x} p_{i_{j}^{x}j}^{x} - kp_{ij}^{x}\right)z_{ikj}} = \max_{z_{ikj}}{\sum_{i=1}^{m} \sum_{j=1}^{n} \sum_{k=1}^{n} c_{ikj}^{x}z_{ikj}} $$

(25)

where z _ikj fulfill (22), (23), and (24) and c ^x _ikj are fixed coefficients, i.e.:

$$ \begin{aligned}c_{ikj}^{x} = \left\{ \begin{array}{lll} k_{j}^{x} \overline{p}_{i_{j}^{x}j} - k \underline{p}_{ij}&&{\rm{if}}\,i_{j}^{x}\neq i,\\ k_{j}^{x} \overline{p}_{i_{j}^{x}j} - k \overline{p}_{ij} && {\rm if}\, i_{j}^{x} = i \wedge k_{j}^{x} > k,\\ k_{j}^{x} \underline{p}_{i_{j}^{x}j} - k \underline{p}_{ij} &&{\rm{if}}\, i_{j}^{x} = i \wedge k_{j}^{x} \leq k. \end{array} \right.\end{aligned}$$

(26)

The problem (25), (22), (23), and (24) is the weighted assignment problem with n jobs and mn positions (Pinedo 2008). This problem can be solved in a polynomial time using well known Hungarian algorithm.

3.3 SS heuristics

In Sect. 3.1 we have described a 2-approximation algorithm for solving the nondeterministic version of $R\Vert \sum C_j.$ Now, as an alternative, we present an evolutionary method—SS.

SS (Laguna and Marti 2003) is the population based algorithm that has been successfully applied to solving hard optimization problems, e.g. (Corberen 2002; Nowicki and Smutnicki 2006; Siepak and Jozefczyk 2011; Xu et al. 2000). The applications of this algorithm to the uncertain version of the various scheduling problems were presented in (Siepak and Jozefczyk 2013). The fundamental concepts of this approach were proposed in 1970s, however, its current state was described in 1998 in (Glover 1997). This method uses strategies for search diversification and intensification in order to avoid stopping at local optima. SS consists of processing the set of possible solutions. The quality of each solution is based on its objective function value and is also characterized by the value of the diversity measure which is specified for the problem. Five separate subprocedures can be distinguished within the SS basic algorithm (Laguna and Marti 2003):

Diversification generation method generates a collection ${\user2{M}}$ of MSize diverse solutions being the starting point of SS.

Improvement method uses local search algorithms to convert the input solution into a new one for which the value of the objective function is better. If no improvement is made, then the original input solution is returned as a result.

Reference set update method updates and maintains a reference set ${\user2{RefSet}}$ containing a specified number of the best solutions found according to the objective function value and the most diverse solutions according to the diversity measure.

Subset generation method based on ${\user2{RefSet}}$ produces all its subsets of the specified cardinality.

Solution combination method combines all solutions within a single subset to obtain the new solution.

The general SS procedure introduced in (Laguna and Marti 2003) can be presented in three steps:

• 1. Start with ${\user2{M}}=\emptyset.$ Use the Diversification generation method to construct a solution and apply the Improvement method. Let x be the resulting solution. If $x \notin {\user2{M}},$ then ${\user2{M}} = {\user2{M}} \cup x.$ Repeat this step until $\left|{\user2{M}}\right|=MSize.$

• 2. Use the Reference set update method to build ${\user2{RefSet}}=\left\{x^{1},\ldots,x^{b}\right\}$ with the best b solutions in ${\user2{M}}.$ Order the solutions in ${\user2{RefSet}}$ according to their objective function values, so x ¹ is the best solution and x ^b is the worst one.

• 3. Assign NewSolutions = true.

Below, we describe how each of the SS subprocedures has been adapted to the structure of the minmax regret version of $R\Vert \sum C_j.$

3.3.1 Diversification generation method

This subprocedure generates a feasible solution x by randomly assigning tasks to the machines and then randomly ordering tasks performed on each machine. The computational experiments performed show that SS returns solutions of better quality when using the random procedure for generating input solutions rather than the deterministic one. The initial schedule generated is modified in the latter step of the procedure in order to fulfill the following property, which improves the total completion time value and is true for each optimal solution (Pinedo 2008).

Property: If task j is assigned to position k > 1 on machine i, then there is also a task assigned to position k − 1 on the machine i. Otherwise, scheduling task j on position k − 1 would improve the total assignment cost.

Input: Number of tasks n, number of machines m.

Output: Feasible solution x.

3.3.2 Improvement method

This method tries to improve the input solution x by moving tasks between machines and by changing the order of tasks execution within the machines.

Input: Solution x to improve.

Output: Improved solution x.

3.3.3 Reference set update method

Let b ₁ denote the maximum number of the highest quality solutions found according to the value of $z(\cdot)$ and b ₂ be the maximum number of the most diverse solutions found within the reference set.

We express the diversity between any two schedules x and y as the sum of the absolute difference between its corresponding variable values x _ikj and y _ikj , i.e.

$$ d\left(x,y\right)=\sum_{i=1}^{m}\sum_{j=1}^{n}\sum_{k=1}^{n} \left|x_{ikj}-y_{ikj}\right|. $$

(27)

For a given set of solutions ${\user2{S}}=\left\{s_{1},\ldots,s_{\left|{\user2{S}}\right|}\right\},$ let $\tilde{d}(x, {\user2{S}})$ express the highest value of the diversity measure found between x and the elements of ${\user2{S}},$ i.e.

$$ \tilde{d}(x, {\user2{S}}) = \max_{i=1,\ldots,\left|{\user2{S}}\right|}{d\left(x,s_{i}\right)}. $$

(28)

Input: ${\user2{RefSet}}$—reference set to update; x—a candidate solution.

Output: ${\user2{RefSet}}$—updated reference set.

Generate sequence $s=(s_{1},\ldots,s_{\left|{\user2{RefSet}}\right|})$ of solutions being elements of ${\user2{RefSet}}$ and sort it ascending according to the value of $z(\cdot).$

There are three main conditions that reference set update method consists of. If any of them is fulfilled, then the candidate solution x is added into ${\user2{RefSet}}$:

Condition 1:

Is the cardinality of the reference set smaller than b ₁?

Condition 2:

Is the quality of x better than the quality of the worst solution $\hat{s}$ in ${\user2{RefSet}}$?

Condition 3:

Is the diversity of x higher than the diversity of the least diverse solution in ${\user2{RefSet}}$? Moreover, in order to not exceed the maximum size of the reference set, i.e. b ₁ + b ₂, if either Condition 2 or Condition 3 is fulfilled, then the solution $\hat{s}$ which has the worst quality in ${\user2{RefSet}}$ is removed from this set.

3.3.4 Subset generation method

For the purpose of the considered uncertain problem, all ${\user2{RefSet}}$ subsets of cardinality 2 are generated. The computational experiments performed shown that generating subsets of higher cardinality does not significantly improve the quality of generated solutions, however it increases execution time of SS.

3.3.5 Solution combination method

This subprocedure generates a new solution

$$ c=\left[c_{ikj}\right]_{i=1,\ldots,m;j,k=1,\ldots,n} $$

(29)

which is the result of combination of input solutions x and y belonging to the single subset of ${\user2{RefSet}}.$ Let us use the notation already introduced in Sect. 3.2

Input: Solution matrices x and y.

Output: Combined solution c.

3.4 Local search algorithm (LS)

In order to motivate the usefulness of SS, it was compared with a simple local search algorithm (LS), used as the improvement method for Scatter Search. It was additionally assumed, that the initial solution for LS is generated by MI. The computational experiments show that the starting point generated in such a way leads to better results than while assuming the random initial solution. The local search algorithm is specified by the following two step procedure:

• 1. Get x″ with the usage of MI algorithm.

• 2. Generate solution $\hat{x}$ by applying SS improvement method to x″.

4 Computational experiments with solution algorithms

4.1 Implementation details

All procedures have been coded in $C\#.$ The implementation of the Hungarian algorithm and its subprocedure—Konig’s algorithm was based on (Nering and Tucker 1993). The computations have been performed on Intel Core i7 2.20 GHz and 8.00 GB of RAM.

4.2 Description of experiments

The proposed algorithms were experimentally evaluated in terms of their quality and execution times. For small data instances, an exact algorithm (EX) based on a simple enumeration serves as the basis for evaluation.

Due to the lack of literature test data instances, a method of generating bounds of the interval execution times was proposed. The parameter ${C \in \mathbb{N}}$ was introduced and the values of $\underline{p}_{ij}$ and $\overline{p}_{ij}$ were selected randomly according to the uniform distribution within intervals $\left[0,C\right]$ and $\left[\underline{p}_{ij},\underline{p}_{ij}+C\right],$ respectively. Parameter C determines the maximum range of intervals where the uncertain parameters belong to. Therefore, it can be treated as the numerical characteristics of the uncertainty.

The test data instances involved scheduling $n \in \left\{10,20,50,100\right\}$ tasks on m = 2 machines and $n \in \left\{20,50,100\right\}$ tasks on m = 10 machines. Moreover, for n = 10, m = 2 SS, LS and MI were compared with EX. All experiments were performed for $C \in \left\{10,30,50,70,100,150\right\}.$ For each configuration of C, m, n, a single problem instance of the problem was generated. SS was repeated 5 times for each instance due to the randomness of diversification generation method and combination method procedures. All execution times of algorithms launched in the experiments are expressed in seconds.

Let, for a given problem instance $x,\tilde{x}_{\rm max}$ and $\tilde{x}_{\rm min}$ denote SS best and SS worst quality solutions, respectively. The following general performance indices were proposed to evaluate the percentage relative difference between given feasible solution x generated by any other algorithm and SS for the worst and the best results generated by SS respectively, i.e.: $\delta_{\rm max}(x)=\frac{z\left(x\right)\,-\,z\left(\tilde{x}_{\rm max}\right)}{z\left(\tilde{x}_{\rm max}\right)}\cdot 100\,\%$ which expresses, for a given problem instance x, how much in percentage the quality of x is worse than the worst quality solution $\tilde{x}_{\rm max}$ generated by SS, $\delta_{\rm min}(x)=\frac{z\left(x\right)\,-\,z\left(\tilde{x}_{\rm min}\right)}{z\left(\tilde{x}_{\rm min}\right)}\cdot 100\,\%$ which expresses, for a given problem instance x, how much in percentage the quality of x is worse than the best quality solution $\tilde{x}_{\rm min}$ generated by SS.

Similar general performance index $\gamma\left(x\right)\,=\,\frac{z\left(x\right)\,-\,z\left(x^{*}\right)}{z\left(x^{*}\right)}\cdot 100\,\%$ was proposed for small problem instances to compare solution x with optimal solution x*.

Tables 1, 2, 3, 4, 5, 6, 7, 8, 9, and 10 present results of the computational experiments. Column C denotes the value of parameter C. Symbols T _EX, T _LS,   T _MI and T _avg denote the execution times of EX, LS, MI and the average execution times of SS, while running it 5 times, respectively. Columns $z\left(\tilde{x}_{\rm min}\right),$ $z\left(\tilde{x}_{\rm avg}\right)$ and z$\left(\tilde{x}_{\rm max}\right)$ denote respectively the minimum, the average and the maximum value of z for SS. Additionally, $z\left(x^{*}\right), \,z\left(x_{\rm LS}\right)$ and $z\left(x_{\rm MI}\right)$ denote respectively the quality of optimal solution x*, LS solution x _LS and 2-approximate MI solution x _MI. In order to simplify the presentation, all values of the regret criteria are rounded to the nearest integer.

Table 1 Results of EX, SS, LS and MI for n = 10, m = 2

The experiments were conducted for MSize = 70,  b ₁ = 7,  b ₂ = 7 as tuned parameters of SS. The results presented for n = 10, m = 2 (Tables 1, 2) enable us to compare SS, LS and MI solutions with the optimal ones. The result is promising, i.e.: the lowest and the highest quality SS solutions are at most 4.3 and 1.1 % worse than the corresponding optimal ones, respectively [see $\gamma\left(\tilde{x}_{\rm min}\right)$ and $\gamma\left(\tilde{x}_{\rm max}\right)$]. The quality of LS and MI solutions differs at least 8.8 and 12.3 % from optimality (columns $\gamma\left(x_{\rm LS}\right)$ and $\gamma\left(x_{\rm MI}\right),$ respectively). According to the results presented in Tables 1, 2, 3, 4, and 5, the values of $\delta_{\rm max}\left(x_{\rm LS}\right)$ and $\delta_{\rm min}\left(x_{\rm LS}\right)$ for m = 2 as well as different n and C, fall within intervals $\left[3.4\,\%, 10.0\,\%\right]$ and $\left[5.4\,\%, 13.0\,\%\right],$ respectively, while $\delta_{\rm max}\left(x_{\rm MI}\right)$ and $\delta_{\rm min}\left(x_{\rm MI}\right)$ belong to $\left[5.2\,\%, 13.2\,\%\right]$ and $\left[6.2\,\%, 16.6\,\%\right].$ The average values of $\delta_{\rm max}\left(x_{\rm LS}\right),$ $\delta_{\rm min}\left(x_{\rm LS}\right),\,\delta_{\rm max}\left(x_{\rm MI}\right)$ and $\delta_{\rm min}\left(x_{\rm MI}\right)$ calculated for m = 2 and different C, which are presented in Table 6, descend for increasing values of n. Similar experiments were performed for m = 10 and different n,  C. Based on the results presented in Tables 7, 8, and 9, the values of $\delta_{\rm max}\left(x_{\rm LS}\right)$ and $\delta_{\rm min}\left(x_{\rm LS}\right)$ belong to $\left[2.4\,\%, 6.1\,\%\right]$ and $\left[4.3\,\%, 10.3\,\%\right],$ respectively, while $\delta_{\rm max}\left(x_{\rm MI}\right)$ and $\delta_{\rm min}\left(x_{\rm MI}\right)$ belong to $\left[2.8\,\%, 8.8\,\%\right]$ and $\left[5.6\,\%, 13.1\,\%\right],$ respectively. The average values of performance indices for m = 10 and different C are presented in Table 10. Analyzing Tables 6 and 10 one can notice, that increasing m from 2 to 10 causes decreasing of δ_min,avg and δ_max,avg for x _LS and x _MI. This means that the average difference in quality of the analysed algorithms decreases while increasing the number of machines. However, even for the largest problem instances, LS solutions are on average at least 3.37 % worse than SS solutions, while MI solutions—at least 4.38 % (see Table 10, n = 100).

Table 2 Values of performance indices for n = 10, m = 2

Table 3 Results of SS, LS and MI for n = 20, m = 2

Table 4 Results of SS, LS and MI for n = 50, m = 2

Table 5 Results of SS, LS and MI for n = 100, m = 2

Table 6 Average values of δ_max and δ_min for m = 2 and different n

Table 7 Results of SS, LS and MI for n = 20, m = 10

Table 8 Results of SS, LS and MI for n = 50, m = 10

Table 9 Results of SS, LS and MI for n = 100, m = 10

Table 10 Average values of δ_max and δ_min for m = 10 for different n

All experiments confirmed that SS outperforms LS and MI in terms of the quality of solutions. Hovewer, the execution time of SS for the largest tested problem instance exceeds 9 h (Table 9), while for MI and LS is less than 4 and 20 min, respectively. The long execution time of SS is caused by the necessity to solve the deterministic problem many times, especially by the improvement method procedure.

5 Conclusions

In this paper we elaborated and compared three solution algorithms for the uncertain version of $R\Vert \sum C_j$ where the execution times of tasks belong to the intevals of known bounds. No other characteristics of uncertain parameters like the probability distribution or the membership function have been given. The robust approach based on the regret criterion was used in order to cope with such an uncertainty. The problem is NP-hard, therefore we proposed 2-approximate algorithm (MI) and the population based heuristic—SS. To justify additionally the usefulness of SS, the simpler heuristics limited only to a local search (LS) was also used. The computational experiments show that SS works much more longer than MI and LS, however it returns solutions up to 14.2 % better than MI and up to 13.4 % better than LS. We recommend to use SS when the solutions quality is important, while LS algorithm, when it is necessary to obtain solutions in a short time, as it combines the advantages of the 2-approximate MI algorithm and the local search method. As an alternative, solution generated by MI can be used as the input of SS, giving the hybrid algorithm as a result. Moreover, a compromise can be reached between the quality of the solution and the computation time by manually terminating SS at any moment. Then, the best solution found is returned as a result.

In order to extend the research performed in this paper, other metaheuristic, e.g. Tabu Search, are also worth investigating. The development of algorithms for other minmax regret task scheduling problems is also planned.