A Combination of Flow Shop Scheduling and the Shortest Path Problem^††thanks: A preliminary version of this paper has appeared in the Proceedings of 19th Annual International Computing and Combinatorics Conference (COCOON’13), LNCS, vol. 7936, pp. 680–687.

We first give a formal definition of our problem, which is a combination of the flow shop scheduling problem and the shortest path problem.

The considered problem is a combination of flow shop scheduling and the classic shortest path problem, mainly because the two optimization problems are special cases of this problem. For example, consider the following instances with $m=2$. If there is a unique path from $s$ to $t$ in $G$, as shown in the left of Fig. 1, our problem is the two-machine flow shop scheduling problem. If all the processing times on the second machine are zero, as shown in the right of Fig. 1, then our problem is equivalent to the classic shortest path with respect to the processing times on the first machine. These examples illustrate that these two optimization problems are inherent in the considered problem.

In this paper, we will use the results of some optimization problems that have a similar structure with the classic shortest path problem. We introduce the following generalized shortest path problem.

For ease of exposition, we use $SP$ instead of $SP(G,s,t,f)$ when there is no danger of confusion. Notice that $SP$ is a generalization of various shortest path problems. For instance, if we consider $K=1$ and $f(w^{1},x)=w^{1}\cdot x$, where $\cdot$ is the dot product, this problem is the classic shortest path problem. If $K=2$ and $f(w^{1},w^{2},x)=\min\{w^{1}\cdot x:w^{2}\cdot x\leq W\}$, where $W$ is a given number, this problem is the shortest weight-constrained path problem (Garey and Johnson, 1979). If $f(w^{1},w^{2},\cdots,w^{K},x)=\max\{w^{1}\cdot x,w^{2}\cdot x,\cdots,w^{K}\cdot x\}$, the problem is the min-max shortest path problem (Kouvelis and Yu, 1997). In the following sections, we will analyze our combined problem by setting appropriate weights and objective function in $SP$.

First, we introduce some trivial bounds for flow shop scheduling. Denote by $C_{max}$ the makespan of an arbitrary flow shop schedule with job set $J$. A feasible shop schedule is called dense when any machine is idle if and only if there is no job that can be processed at that time on that machine. For arbitrary dense flow shop schedule, we have

and

For each job, we have

In flow shop scheduling problems, a schedule is called a permutation schedule if all jobs are processed in the same order on each machine. Conway et al. (1971) proved that there always exists a permutation schedule which is optimal for $F2||C_{max}$ and $F3||C_{max}$. In a permutation schedule, the critical job and critical path are important concepts for the analysis of related algorithms.

Suppose we are given a job set $J$ with $n$ jobs. Let $\sigma=(\sigma(1),\cdots,\sigma(n))$ be a permutation of $(1,\cdots,n)$ for a three-machine (or two-machine) flow shop, and let $\{J_{\sigma(1)},J_{\sigma(2)},\cdots,J_{\sigma(n)}\}$ be the corresponding schedule. For simplicity of notation, we denote the permutation and the schedule by $(1,2,\cdots,n)$ and $\{J_{1},J_{2},\cdots,J_{n}\}$ respectively. A directed graph is defined as follows. We define a vertex $(i,j)$ with an associated weight $p_{i,j}$ for each job $J_{j}$ and each machine $M_{i}$, for $i=1,2,3$ (or $i=1,2$) and $j=1,2,\cdots,n$. We include arcs leading from each vertex $(i,j)$ towards $(i+1,j)$, and from $(i,j)$ towards $(i+1,j+1)$ for $j=1,\cdots,n-1$. The total weight of a maximum weight path from $(1,1)$ to $(3,n)$ (or $(2,n)$), which is called a critical path, is equal to the makespan of the corresponding permutation schedule. For the three-machine case, the critical jobs with respect to $\sigma$ are defined as the jobs $J_{u}$ and $J_{v}$ such that $(1,u)$, $(2,u)$, $(2,v)$ and $(3,v)$ appear in the critical path, i.e. the jobs $J_{u}$ and $J_{v}$ satisfy

For the two-machine case, the critical job with respect to $\sigma$ is defined as the job $J_{\nu}$ such that $(1,\nu)$ and $(2,\nu)$ appear in the critical path, i.e. the job $J_{\nu}$ satisfies

Johnson (1954) proposed a sequencing rule for $F2||C_{max}$, which is one of the oldest results of the scheduling literature, and is commonly referred to Johnson’s rule.

In Johnson’s rule, jobs are scheduled as early as possible. This rule produces a permutation schedule, and Johnson showed that this schedule is optimal. Notice that this schedule is obtained in $O(n\log n)$ time.

For the general problem $Fm||C_{max}$, Gonzalez and Sahni (1978) first presented an $\lceil\frac{m}{2}\rceil$-approximation algorithm that runs in $O(mn\log{n})$ time by solving $\lceil\frac{m}{2}\rceil$ two-machine flow shop scheduling problems. Röck and Schmidt (1982) proposed an alternative approach by reducing the original problem to an artificial two-machine flow shop problem; this approach is called machine aggregation heuristic. They obtained a permutation by solving the artificial problem in $O(mn+n\log n)$ time, and proved that it has the same performance guarantee of $\lceil\frac{m}{2}\rceil$. Based on the machine aggregation heuristic, Chen et al. (1996) proposed an algorithm for $F3||C_{max}$ with an improved performance guarantee of $\frac{5}{3}$. In the same paper, they also modified the Gonzalez and Sahni’s algorithm if $m$ is odd, by partitioning the machines into $\frac{m-3}{2}$ two-machine flow shop scheduling problems, and one three-machine flow shop scheduling problem which was solved by their $\frac{5}{3}$-approximation algorithm. The modified algorithm has the same performance ratio $\frac{m}{2}$ if $m$ is even, and an improved ratio $\frac{m}{2}+\frac{1}{6}$ if $m$ is odd. It is known that a PTAS exists for $Fm||C_{max}$ (Hall, 1988).

We refer to the aggregation heuristic of Röck and Schmidt (1982) as the RS algorithm, and we will use it later to derive an algorithm for our combined problem. The RS algorithm can be described as follows for the three-machine case.

The running time of this algorithm is $O(n\log n)$, which is the same as Johnson’s rule. Notice that the algorithm returns a permutation schedule, and hence the resulting makespan $C_{max}$ satisfies the equality (4).

In this paper, we will use the following two results of the shortest path problems. The first one is the well-known Dijkstra’s algorithm, which solves the classic shortest path problem with nonnegative edge weights in $O(|V|^{2})$ time (Dijkstra, 1959). The second one is a FPTAS result for the min-max shortest path problem, which is presented by Aissi, Bazgan and Vanderpooten (2006). Kouvelis and Yu (1997) first proposed min-max criteria for several problems, including the shortest path problem. Aissi, Bazgan and Vanderpooten (2006) studied the computational complexity and proposed several approximation schemes. The min-max shortest path problem with $K$ weights $w^{1}_{j},\cdots,w^{K}_{j}$ associated with each arc $a_{j}$, is to find a path $P$ between two specific vertices that minimizes $\max_{k\in\{1,\cdots,K\}}\sum_{a_{j}\in P}w^{k}_{j}$. It was shown that this problem is NP-hard even for $K=2$, and that a FPTAS exists if $K$ is a fixed number (Warburton, 1987; Aissi, Bazgan and Vanderpooten, 2006). The algorithm of Aissi, Bazgan and Vanderpooten (2006), referred to the ABV algorithm in this paper, is based on dynamic programming and scaling techniques. The following result implies that the ABV algorithm is a FPTAS if $K$ is a constant.

To start off, we propose an intuitive algorithm for $Fm|\mathrm{shortest}~\mathrm{path}|C_{max}$. The main idea of this algorithm is to set $K=1$ and $f=w^{1}\cdot x$ in $SP$, i.e. to find a classical shortest path with one specific set of weights. An intuitive setting is $w^{1}_{j}=\sum^{m}_{i=1}p_{ij}$ for each arc. We find the shortest path with respect to $w^{1}$ by Dijkstra’s algorithm, and then schedule the corresponding jobs on the flow shop machines. We refer to this algorithm as the FD algorithm. The subsequent analysis will show that the performance ratio of the FD algorithm remains the same for an arbitrarily selected flow shop scheduling algorithm that provides a dense schedule, regardless of the performance ratio of the algorithm.

It is straightforward that the total running time of the FD algorithm is $O(|V|^{2}+T(m,n))$, where $T(m,n)$ is the running time of the flow shop scheduling algorithm. Therefore, suppose the flow shop scheduling algorithm we used is polynomial time, then the FD algorithm is polynomial time even if $m$ is an input of the instance. Before we analyze the performance of this algorithm, we first introduce some notations. Let $J^{*}$ be the set of jobs in an optimal solution, and $C^{*}_{max}$ be the corresponding makespan, and let $S$ and $C_{max}$ be those returned by the FD algorithm respcetively.

In this subsection, we assume that $m$, the number of flow shop machines, is a constant. Instead of finding an optimal shortest path from $s$ to $t$ with respect to specific weights, we implement the ABV algorithm mentioned in Section 2.3, which will return a $(1+\epsilon)$-approximated solution for the min-max shortest path problem. In other words, we will set $K=m$ and use the objective function $f=\max\{w^{1}\cdot x,w^{2}\cdot x,\cdots,w^{K}\cdot x\}$ in $SP$, where the wights $w^{1},w^{2},\cdots,w^{K}$ will be decided later.

Inspired by the work of Gonzalez and Sahni (1978) and Chen et al. (1996), we proceed as follows: after obtaining a feasible path by the ABV algorithm, we schedule the corresponding jobs by partitioning the $m$ machines into several groups. Denote the machine as $M_{i}$, $i=1,\cdots,m$ (indexed following the routing of the flow shop). More specifically, we partition the $m$ machines into $m_{3}$ groups of three consecutive machines in the routing $M_{3i-2}$, $M_{3i-1}$, $M_{3i}$ ($i=1,\cdots,m_{3}$), $m_{2}$ groups of two consecutive machines in the routing $M_{3m_{3}+2i-1}$, $M_{3m_{3}+2i}$ ($i=1,\cdots,m_{2}$), and $m_{1}$ individual machines $M_{3m_{3}+2m_{2}+i}$ ($i=1,\cdots,m_{1}$), in which the value of $m_{1}$, $m_{2}$, $m_{3}$ will be derived later. For the three-machine subproblems on $M_{3i-2}$, $M_{3i-1}$ and $M_{3i}$ ($i=1,\cdots,m_{3}$), we implement the RS algorithm to obtain the permutations. For the two-machine subproblems on $M_{3m_{3}+2i-1}$ and $M_{3m_{3}+2i}$ ($i=1,\cdots,m_{2}$), we implement Johnson’s rule to obtain the permutations. The permutations for the single-machine subproblems are arbitrary. Then we form a schedule for the original $m$-machine problem, in which the sequences of jobs on machines $M_{i}$ are the permutations obtained above, and are executed as early as possible. Notice the property that an optimal schedule is always a permutation schedule only stands for $F2||C_{max}$ and $F3||C_{max}$, and the performance guarantee relies on the properties of critical jobs as we will see in the subsequent analysis. The reason why we partition the $m$ machines in this particular fashion is related to this fact, as will be explained below.

The main idea of our algorithm is described as follows. We initially set the weights $(w^{1}_{j},w^{2}_{j},\cdots,w^{m}_{j})=(p_{1j},p_{2j},\cdots,p_{mj})$. The algorithm iteratively runs the ABV algorithm and the above partition scheduling algorithm (the values of $m_{1},m_{2},m_{3}$ will be decided later) by adopting the following revision policy: in a current schedule, if there exists a job whose weight is large enough with respect to the current makespan, we will modify the weights of arcs corresponding to large jobs to $(M,M,\cdots,M)$, where $M$ is a sufficient large number, and then mark these jobs. The algorithm terminates if no such job exists. Another termination condition is that a marked job appears in a current schedule. We return the schedule with minimum makespan among all current schedules as the solution of the algorithm. We refer to this algorithm as the PAR algorithm. Notice that the weights of arcs may vary in each iteration, whereas the processing times of jobs remain the same throughout this algorithm.

Before we formally state the PAR algorithm, we first provide more details about the parameter choices. For $m=2$ and $m=3$, by following the subsequent analysis of the performance of this algorithm, one can verify that the best possible performance ratio is $\frac{3}{2}$ and $2$ respectively. An intuitive argument is that the best possible performance ratio for the general case of the PAR algorithm is $\rho=m_{1}+\frac{3}{2}m_{2}+2m_{3}$. For a given $m$, as $m_{1},m_{2},m_{3}$ are nonnegative integers, our task is to minimize $m_{1}+\frac{3}{2}m_{2}+2m_{3}$ such that $m_{1}+2m_{2}+3m_{3}=m$. A simple calculation yields the following result:

and

In other words, the best way is to partition the machines in such a way that we have a maximum number of three-machine subsets. The pseudocode of the PAR algorithm is described by Algorithm 4.

It is easy to see that the PAR algorithm will return a feasible solution of $Fm|\mathrm{shortest}~\mathrm{path}|C_{max}$. We now discuss its computational complexity. Let the total number of jobs be $|A|=n$. Notice that the weights of arcs can be revised at most $n$ times. It is straightforward that the total running time of the PAR algorithm is $O(n^{2}|V|^{m+1}/\epsilon^{m}+mn^{2}\log n)$, since there are at most $n$ iterations, in which the running time of the ABV algorithm is $O(n|V|^{m+1}/\epsilon^{m})$ and scheduling takes $O(mn\log n)$ time. If $m$ and $\epsilon$ are fixed numbers, then the PAR algorithm is a polynomial time algorithm.

Let $J^{*}$ be the set of jobs in an optimal solution, and $C^{*}_{max}$ the corresponding makespan, and let $S$ and $C_{max}$ be those returned by the PAR algorithm respectively. The following theorem shows the performance of the PAR algorithm.