Vehicle Scheduling Problem

I Introduction

Vehicle scheduling problem (VSP) is a new scheduling problem that we define in this work. Many of the scheduling problems in the literature are motivated by real life applications. The motivation for defining this new scheduling problem is the impending integration of the Unmanned Aerial Vehicles (UAVs) in the airspace and a lack of framework for accommodating them in a scalable way. They will be used in a wide array of applications from search and rescue, to package delivery, traffic enforcement, infrastructure inspection and cinematography. This means in any city, there will be a high amount of congestion that needs to be managed to prevent mid-air collisions as well as to provide an efficient service[5]. While our main motivation comes from the application of UAVs, our scheduling problem is generic and malleable enough to use in other areas as well.

On a high level, the problem we try to solve is as follows. We are given a path over a graph for each vehicle. Our goal is to minimize the number of tardy vehicles (or any other objective function) subject to the deadlines, minimum and maximum allowed speeds on the links, and separation time gap needed when entering the nodes (which play the role of intersections).

We first compare VSP with a large class of scheduling problems known as Job Shop Scheduling (JSP). The Job Shop Scheduling problem comes in many types which are motivated by the real life problems they strive to solve. Therefore, given the vast amount of literature on the subject, a first point of attack will be to model our problem in terms of a variant of JSP. In the classic Job Shop Scheduling problem, we are given a set of jobs, each composed of a chain of operations, and each operation can be performed on a specific machine from the set of all machines. A machine can only process one operation at a time at a specified processing time. At first sight, it seems the nodes in our graph can be simulated by machines and the separation time is analogous to the processing time. However, upon further inspection, it is not clear how to model the time it takes for a vehicle to reach from one node to another. Of course, this does not seem possible in a straightforward way using the classical type. However, even using variants of JSP with properties including BLOCKING, NO-WAIT, SETUP TIMES, etc. does not seem to represent our problem in an uncomplicated way. In JSP with BLOCKING, machines will hold up the operation and remain busy if the next machine is busy which corresponds to a lack of buffer between machines. In JSP with NO-WAIT, a task cannot wait between machines. In JSP with SETUP TIMES, there will be a time delay to set up a new job on a machine. For a reference to these variants of JSP, look at e.g. [13].

Some researchers have extended JSP and these more or less standardized variants to include transportation times between the machines. That is for a job to start executing in the next machine, it will be delayed by the transportation time between the previous machine and the new one. For instance, see [7] and [14]. However, in these cases, the transportation time is fixed whereas in VSP the velocity over a link can be chosen from a range. Furthermore, in some of these works, one or more robots are used for transportation with empty trips as necessary which again does not have a resemblance to our work [7],[6].

scheduling in computer networks is another area with a vast literature. However, the underlying structure in computer networks is different. Firstly, the bottleneck are the router buffers (similar to the nodes in our case) and the packets spend most of their time in the routers whereas in our case vehicles spend only a minimal amount of time at a node and spend most of their times travelling on the links. Another difference is that packets might drop (i.e. vanish if needs be), but this is not an option for the vehicles. Furthermore, the velocity of each packet during transmission on a link is constant and equal whereas vehicles can have different velocities over the links. These results in drastically different scheduling algorithms and policies which makes it difficult to use in VSP [12].

For the application of scheduling of Unmanned Aerial Vehicles, we are aware of one work [16]. However, the authors formulate the problem as a joint optimization of routing and scheduling whereas in our case we are only interested in the scheduling aspect. This is a valid problem on its own as for various reasons, as the operator, we might not be authorized to make routing decisions. For instance, the government might restrict UAV flights for a company to only certain paths.

In the context of air traffic management, the problems are formulated differently and the algorithms being used are not directly applicable to our problem. To be more precise, in the context of air traffic management, the air space is separated into sectors that are basically a volume of airspace and the goal is to avoid over loading each sector by means of either postponing the flight or changing the calculated route for a flight [2, 11]. Therefore the underlying graph structure in our problem is different.

An area of research that has some similarities is the train scheduling literature. There are similarities and differences between our approach. Similar to us, some of the train scheduling problems use a Mixed Integer Programming (MIP) model and a similar idea of treating arrival Time Stamps at a segment as a modelling variable. But most of these models are designed for a single main line with multiple short segments attached to the main line where trains can effectively park and let other trains take over before continuing their travel on the main line. There will be different set of constraints as well involved such as assignment of locomotives and crews which do not have a counterpart for unmanned aerial vehicles[4, 3].

I-a Our contribution

Our contribution can be summarized as follows.

We define a new scheduling problem called Vehicle Scheduling Problem and formulate it in terms of a mixed integer linear programming. Our model has applications among other things to movements of autonomous vehicles over a transportation network; especially autonomous unmanned aerial vehicles. The model is versatile in that we can model vehicles with various minimum and maximum speeds as well as upperbounds on deadlines. Furthermore, we can adjust the safety gap as needed per pair of vehicles for each intersections (that is nodes of the graph).

We then proceed to show the NP-hardness of VSP for all commonly used objective functions in the context of job shop scheduling problems. These include minimizing

Makespan: The time the last vehicle exits the graph.
Total (weighted) completion time: Total or (equivalently) the average travel time with potentially different weights for different vehicles.
Maximum lateness: The maximum (positive or negative valued) difference between deadline and trip completion of all vehicles.
Total tardiness: The total time past deadlines
(weighted) number of tardy vehicles: The number of vehicles that missed their deadlines.

It is possible to provide an MIP of VSP for all these objective function. To demonstrate that, we pick the objective function of number of tardy vehicles and give an MIP formulation of VSP. To deal with the computational complexity of VSP in this case, we devise a heuristic algorithm in the case where all trips are requested at the same time. We analyze the complexity of our algorithm and compare the solutions yielded from our algorithm to the optimal solution to MIP for a few random instances with a small number of vehicles. We also compare these results to a baseline algorithm that we designed.

Finally, we conclude with a discussion of the shortcomings of our algorithm such as sensitivity to noise as well as ideas for future improvement.

Ii Problem Definition

We first give an informal definition of VSP and then proceed to define it in a more rigorous way.

In VSP, we are given a number of vehicles each of which request to make a trip at some point in time. Trips take place over a transportation network which is abstracted away as a graph. Each trip consists of a sequence of edges on this graph. We can have unlimited vehicles on each edge travelling at the same time, but when any two vehicles reach a vertex (i.e. intersection), they must be separated by some separation time constant. Therefore, to minimize some objective function (e.g. number of tardy vehicles) we have to schedule vehicles in a way that minimizes the congestion or prioritizes certain vehicles. The velocity of each vehicle on each link must be between a minimum and a maximum velocity. Given the length of the link, one can instead find the minimum and maximum allowed time on the link. In the formal definition, instead of formulating in terms of velocities, we use these time constants. Each vehicle has to meet its trip completion hard deadline. The goal is to assign an arrival time for each vehicle at each vertex on their way (i.e. the schedule) such that the objective function is minimized.

Now, we define VSP in a more rigorous way.

Definition II.1 (Vehicle Scheduling Problem (VSP)).

An instance of VSP is a $9$ -tuple $(G, W, τ_{m i n}, τ_{m a x}, ρ, d, d^{'}, S, f)$ as follows. Graph $G = (V, E)$ is a directed connected graph that represents the traffic network. The set $W = {W_{1}, W_{2}, \dots, W_{n}}$ is a set of directed walks on $G$ and $W_{j} = (W_{j}^{1}, W_{j}^{2}, \dots, W_{j}^{q_{j}}) \in V^{q_{j}}$ is the sequence of vertices vehicle $j$ will visit. Time constants $τ_{m i n}$ and $τ_{m a x}$ are the set of minimum and maximum allowed times for a vehicle to reach its next vertex in the walk. Accordingly, for each vehicle $j$ , $τ_{m i n, j}$ takes the form $τ_{m i n, j} = (τ_{m i n, j}^{1}, τ_{m i n, j}^{2}, \dots, τ_{m i n, j}^{q_{j} - 1})$ . In a similar way, $τ_{m a x, j}$ is defined. The $n$ -tuple $ρ \in R^{n}$ denotes the trip request times and hard deadline $d^{'} \in R^{n}$ is the maximum allowed delays for completing the walks. Soft deadline $d \in R^{n}$ is the maximum allowed delays after which depending on the objective function, a penalty will incur. The set $S$ is a set of elements $s_{j_{1}, j_{2}}^{i_{1}, i_{2}} \in R$ that specify the time separation between distinct vehicles $j_{1}$ and $j_{2}$ when performing the $i_{1}$ ’th and $i_{2}$ ’th step of their walks, respectively. Each element $s_{j_{1}, j_{2}}^{i_{1}, i_{2}}$ is defined only if vertices $W_{j_{1}}^{i_{1}}$ and $W_{j_{2}}^{i_{2}}$ are identical.

Subject to the following constraints, the goal is to find a set $t = {t_{1}, t_{2}, \dots, t_{n}}$ where for each vehicle $j$ , $t_{j} = (t_{j}^{1}, t_{j}^{2}, \dots, t_{j}^{q_{j}})$ assigns to each vertex $W_{j}^{i}$ an arrival time stamp while the objective function $f : R^{q} \mapsto R$ is minimized. Note that we define $q = \sum_{1 \leq j \leq n} q_{j}$ and $f$ takes the arrival time stamps $t_{j}^{i}$ as the input.
Constraints:
Trip request time, trip continuity, and hard deadline:

ρ_{j} \leq t_{j}^{1} \leq t_{j}^{2} \leq \dots \leq t_{j}^{q_{j}} \leq d_{j}^{'}

(1)

Minimum and maximum allowable link travel time:

τ_{m i n, j}^{i} \leq t_{j}^{i + 1} - t_{j}^{i} \leq τ_{m a x, j}^{i}

(2)

Separation enforcement:

| t_{j_{1}}^{i_{1}} - t_{j_{2}}^{i_{2}} | \geq s_{j_{1}, j_{2}}^{i_{1}, i_{2}}

(3)

In the definition above, only the vertices are included in the description of the walk and not the edges. In our definition, since edges have unlimited capacity, we do not concern ourselves with the particular edge that is chosen. However, in real life application, the length of a link and the minimum and maximum velocity among other factors might limit us to a particular edge.

Iii NP-hardness proof

In the general case, VSP is NP-hard. We prove this for various objective functions. First we define the GENERALIZED K-MACHINE UNIT JOB SHOP PROBLEM. For the cases $K = 3$ and $K = 2$ , these problems are already defined in [10] and [8] (with no release dates, deadlines, or no-wait condition), respectively. Since our goal is to reduce this problem to VSP, we do not use the more or less standard notation for JSP since it makes the description of the reduction difficult.

Definition III.1 (GENERALIZED K-MACHINE UNIT JOB SHOP PROBLEM: optimization version).

An instance of GENERALIZED K-MACHINE UNIT JOB SHOP PROBLEM is a $6$ -tuple $(M, J, r, δ, θ, f)$ where $M$ is a set of machines $M = {M_{1}, M_{2}, \dots, M_{K}}$ , and $J$ is a set of jobs ${J_{1}, J_{2}, \dots, J_{n}}$ . Each job $J_{j} = (M_{j}^{1}, M_{j}^{2}, \dots, M_{j}^{q_{j}}) \in M^{q_{j}}$ denotes a sequence of machines that will each process job $J_{j}$ in order, for a duration of one time unit. The $n$ -tuple $r = (r_{1}, r_{2}, \dots, r_{n})$ denotes the release dates and $δ = (δ_{1}, δ_{2}, \dots, δ_{n})$ denotes the deadlines corresponding to each job, respectively. Additionally, $θ$ is a Boolean parameter that is $t r u e$ if jobs cannot wait between machines, otherwise $f a l s e$ .

Subject to the following constraints, the goal is to find a set $x = {x_{1}, x_{2}, \dots, x_{n}}$ where for each job $j$ , $x_{j} = (x_{j}^{1}, x_{j}^{2}, \dots, x_{j}^{q_{j}})$ assigns to each operation $J_{j}^{i}$ a starting time on their associated machine while the objective function $f : R^{q} \mapsto R$ is minimized. Note that we define $q = \sum_{1 \leq j \leq n} q_{j}$ and $f$ takes the arrival time stamps $x_{j}^{i}$ as the input.
Constraints:
– Operations done in order, i.e. $x_{j}^{i} + 1 \leq x_{j}^{i + 1}$ .
– Any machine can process only one operation at a time, i.e. for any distinct $j_{1}, j_{2}$ , if there exists $i_{1}, i_{2}$ such that $J_{j_{1}}^{i_{1}} = J_{j_{2}}^{i_{2}}$ , then $∣ ∣ x_{j_{1}}^{i_{1}} - x_{j_{2}}^{i_{2}} ∣ ∣ \geq 1$ .
– No job scheduled before its release date, i.e. $x_{j}^{1} \geq r_{j}$ .
– If deadlines are hard deadlines, then meeting deadlines, i.e. $x_{j}^{q_{j}} \leq δ_{j}$ .
– No-wait condition, i.e. if $θ$ is $t r u e$ , for any $j$ and any $i$ with $1 \leq i \leq q_{j} - 1$ , we have $x_{j}^{i} + 1 = x_{j}^{i + 1}$ .

We first show there is an efficient reduction from GENERALIZED K-MACHINE UNIT JOB SHOP PROBLEM with an arbitrary objective function to VSP.

Theorem 1.

GENERALIZED K-MACHINE UNIT JOB SHOP PROBLEM has a polynomial time reduction to VSP.

Proof.

The input to GENERALIZED K-MACHINE UNIT JOB SHOP is a $6$ -tuple $(M, J, r, δ, θ, f)$ . The input to VSP is a $9$ -tuple $(G, W, τ_{m i n}, τ_{m a x}, ρ, d, d^{'}, S, f)$ . We generate an input to the latter, for every input to the former. We set $G$ with vertices $V_{1}, V_{2}, \dots, V_{K}$ to be a complete digraph with $K$ vertices. We establish a one-to-one correspondence between the jobs in $J$ and walks in $W$ as follows. Assuming $| J | = n$ and job $J_{j}$ has a length of $q_{j}$ ; for $1 \leq j \leq n$ and the job $J_{j} = (M_{j}^{1}, M_{j}^{2}, \dots, M_{j}^{q_{j}})$ , we create a corresponding walk $W_{j} = (W_{j}^{1}, W_{j}^{2}, \dots, W_{j}^{q_{j}})$ where $W_{j}^{i} = V_{j^{'}}$ if and only if $M_{j}^{i} = M_{j^{'}}$ . The sequences $ρ$ , $d$ , and $d^{'}$ will have a length of $n$ and for any $j$ , both $τ_{m i n, j}$ and $τ_{m a x, j}$ have length $q_{j} - 1$ . Next, we set $τ_{m i n, j} = (1, 1, \dots, 1)$ . If $θ$ is $f a l s e$ (i.e. jobs can wait), we set $τ_{m a x, j} = (+ \infty, + \infty, \dots, + \infty)$ , otherwise if $θ$ is $t r u e$ (no-wait), $τ_{m a x} = (1, 1, \dots, 1)$ . We set $ρ = r$ . For the deadlines, if $δ$ is a hard deadline, we set $d = d^{'} = δ$ . However, if $δ$ is a soft deadline, we set $d = δ$ and $d^{'} = + \infty$ . Lastly, we will use the same objective function $f$ in the reduction with arguments changing from $x_{j}^{i}$ to $t_{j}^{i}$ . This completes the conversion of the inputs. Now, to translate the solution for VSP to GENERALIZED K-MACHINE UNIT JOB SHOP is straightforward. To convert the outputs, for any arrival time stamps $t_{j}^{i}$ for $1 \leq j \leq n$ , we let $x_{j}^{i} = t_{j}^{i}$ , and with this, the reduction is complete. ∎

We prove NP-hardness for all commonly used objective functions in the context of job shop scheduling [13].

Theorem 2.

VSP with any of the following objective functions is NP-hard.

Minimizing:

Makespan ( $C_{m a x}$ )
Total completion time ( $\sum C_{j}$ )
Total weighted completion time ( $\sum w_{j} C_{j}$ )
Maximum lateness (lateness can be positive, 0, or negative for each vehicle) ( $L_{m a x}$ )
Total tardiness (0 or positive for each vehicle) ( $\sum T_{j}$ )
Weighted number of tardy (or late) vehicles ( $\sum w_{j} U_{j}$ )
Number of tardy (or late) vehicles ( $\sum U_{j}$ )

Proof.

For any of these objective functions, we refer to a special case of GENERALIZED K-MACHINE UNIT JOB SHOP PROBLEM that is proven NP-hard in the literature. Then, by applying Theorem 1, the NP-hardness of VSP is established for that objective function. In the following, the objective functions related to tardy vehicles correspond to tardy jobs in the context of JSP problem.

Makespan: GENERALIZED K-MACHINE UNIT JOB SHOP is NP-hard according to [10], where $K = 3$ and all jobs are released at time $0$ ( $r_{j} = 0$ ) and there is no deadline ( $d_{j} = + \infty$ ) and the jobs can wait ( $θ = f a l s e$ ). This problem is referred to as 3-MACHINE UNIT JOB SHOP.

Total tardiness: GENERALIZED K-MACHINE UNIT JOB SHOP PROBLEM with $K = 2$ and the same setting as in the Makespan case above is NP-hard. This problem is referred to as 2-MACHINE UNIT JOB SHOP [8, 15].

Total (weighted) completion time, (Weighted) number of tardy vehicles: Using the same setting as above for 2-MACHINE UNIT JOB SHOP PROBLEM with release dates, this problem is NP-hard. Note that without the release dates, this problem is polynomially solvable [8, 9, 15].

Maximum lateness: For similar setting as in the case of Total Completion Time, 2-MACHINE UNIT JOB SHOP PROBLEM where jobs cannot wait between two machines ( $θ = t r u e$ ) is strongly NP-hard [15]. ∎

Iv Exact MIP formulation

In the next section, we give an MIP formulation of the VSP where to demonstrate, we use the number of tardy vehicles as our objective function. It is possible to develop MIP formulation for the other objective functions as well by perhaps introducing more variables and doing the necessary minor adjustments.

Iv-a Notations

We use the same notation from VSP problem and some additional notations as follows.

Variables $P_{j_{1}, j_{2}}^{i_{1}, i_{2}}$ , $N_{j_{1}, j_{2}}^{i_{1}, i_{2}}$
, decision binary variable
$b_{j_{1}, j_{2}}^{i_{1}, i_{2}}$ , and a large fixed number $M_{j_{1}, j_{2}}^{i_{1}, i_{2}}$ will be used to convert the absolute value constraints to mixed integer linear constraints. The decision binary variable will effectively decide between each pair of vehicles with a conflicting node, which one will have the right of way.
Variable $l_{j}$ will designate a late vehicle, $X_{j}$ will designate how late vehicle $j$ is and a large fixed number $M_{j}$ will be used to convert the constraints of form $X_{j} = max (0, d_{j}^{'} - t_{j}^{q_{j}})$ into mixed integer linear constraints. We add variable $d_{j}$ to designate a soft deadline that a vehicle will strive to meet. On the other hand, the hard deadline $d_{j}^{'}$ must be met to have a feasible solution.

Iv-B Objective function

We use the total number of tardy vehicles as our objective function.

min \sum 1 \leq j \leq n l_{j} .

(4)

Iv-C Constraints

We use the same constraints as in Definition II.1 except for the constraints that follow. The first constraint is the separation enforcement constraint of Eq. 3 where through the standard techniques, the absolute value constraint can be converted to a set of three mixed integer linear constraints.

t_{j_{1}}^{i_{1}} - t_{j_{2}}^{i_{2}} = P_{j_{1}, j_{2}}^{i_{1}, i_{2}} - N_{j_{1}, j_{2}}^{i_{1}, i_{2}}

(5)

b_{j_{1}, j_{2}}^{i_{1}, i_{2}} \cdot s_{j_{1}, j_{2}}^{i_{1}, i_{2}} \leq P_{j_{1}, j_{2}}^{i_{1}, i_{2}} \leq b_{j_{1}, j_{2}}^{i_{1}, i_{2}} \cdot M_{j_{1}, j_{2}}^{i_{1}, i_{2}}

(6)

(1 - b_{j_{1}, j_{2}}^{i_{1}, i_{2}}) \cdot s_{j_{1}, j_{2}}^{i_{1}, i_{2}} \leq N_{j_{1}, j_{2}}^{i_{1}, i_{2}} \leq (1 - b_{j_{1}, j_{2}}^{i_{1}, i_{2}}) \cdot M_{j_{1}, j_{2}}^{i_{1}, i_{2}}

(7)

Furthermore, we convert the late vehicle constraints into the acceptable form for a linear integer programming instance using familiar techniques as follows.

d_{j} - t_{j}^{q_{j}} \leq X_{j}

(8)

0 \leq X_{j}

(9)

X_{j} \leq M_{j} \cdot (1 - l_{j})

(10)

X_{j} \leq d_{j} - t_{j}^{q_{j}} + M_{j} \cdot l_{j}

(11)

V Scheduling algorithms

V-a Baseline algorithm: PROXIMITY

We introduce this baseline algorithm with the purpose of comparing its result to the result from the heuristic algorithm introduced in the next section. Our goal is to establish the superiority of the latter algorithm.

The algorithm PROXIMITY resembles the decentralized heuristics used by car drivers in the real world and is as follows. Each vehicle on a link attached to an intersection will access that intersection at the earliest possible time, if and only if it is the closest (in time) vehicle to cross that intersection. An implementation of this algorithm is shown in Fig. 1 and Fig. 2 with $m o d e$ variable set accordingly.

V-B Heuristic algorithm: DEADLINE & PROXIMITY

Our heuristic algorithm is as follows. The algorithm returns the best solution from three independent subroutines.

PROXIMITY : It is the baseline algorithm introduced earlier.
ABS DEADLINE & PROXIMITY: It is similar to PROXIMITY with the difference that among vehicles of equal (time) distance, the ones with a lower so called delay slack are prioritized over those with higher values. We calculate the delay slack for a vehicle as the difference between its deadline and the shortest trip time possible. However, if no delay slack is left; that is the calculated delay slack is a negative quantity, we give these vehicles the lowest priorities and among themselves, they will cross the intersection in arbitrary orders.
REL DEADLINE & PROXIMITY: It is similar to the previous subroutine except that the delay slack is divided by the number of intersections left in the trip.

An implementation for each of these subroutines is shown in Fig. 1 and Fig. 2 with $m o d e$ variable set accordingly.

0: paths for vehicles,

m o d e

0: time stamps for each node

t i m e S t a m p S e q u e n c e = []

//empty list

a l l V e h i c l e s L i s t =

list of all vehicles

3: sort

a l l V e h i c l e s L i s

t ascendingly using

S o r t i n g K e y

for comparison

4: for all

v e h i c l e

a l l V e h i c l e s L i s t

5: assign earliest possible time stamp to the

v e h i c l e

’s first node and update data structures

6: if does not exist, add time stamp to

t i m e S t a m p S e q u e n c e

in a sorted increasing order

7: end for

8: while

l e n g t h (t i m e S t a m p S e q u e n c e) > 0

t = t i m e S t a m p S e q u e n c e [0]

10:

c u r V e h L i s t =

list of all unfinished vehicles with time stamp

t

for their current node

11: for all

v

c u r V e h L i s t

12:

N =

next node in path of

v

13:

c o n f l i c t V e h L i s t =

list of all vehicles with

N

in their trip

14:

c u r V e h N e x t N L i s t =

list of all vehicles with next node

N

and arrival time stamp

t

on their current node

15: sort

c u r V e h N e x t N L i s t

ascendingly using

s o r t i n g K e y

for comparison

16: for all

v 2

c u r V e h N e x t N L i s t

17: if

v 2

has no time stamp for

N

then

18: assign the earliest time stamp for

N

for

v 2

that satisfies separation constraints imposed by

c o n f l i c t V e h L i s t

and update data structures

19: else

20: continue

21: end if

22: if does not exist, add this time stamp to

t i m e S t a m p S e q u e n c e

in a sorted increasing order

23: end for

24: end for

25: delete

t i m e S t a m p S e q u e n c e [0]

26: end while

Fig. 1: A subroutine to calculate the time stamps for vehicles. Depending on our input to the algorithm

m o d e

variable, the time stamps are calculated using the baseline rule or our heuristic rule.

v e h i c l e

m o d e

0: A two tuple to be used for sorting by first element and then the second element

f i r s t =

time distance to next node

2: if

m o d e

is PROXIMITY then

s e c o n d =

None

4: else if

m o d e

is ABS DEADLINE & PROXIMITY then

s e c o n d = max (0,

remaining delay slack

)

6: else if

m o d e

is REL DEADLINE & PROXIMITY then

s e c o n d = max (0,

delay slack

/

number of remaining of nodes

)

8: end if

9: return (first,second)

Fig. 2: The

S o r t i n g K e y

subroutine returns a 2-tuple for each vehicle that determines their local priority based on the chosen rule.

V-C Complexity

The implementation of the three subroutines mentioned above are the same with minor differences in the $S o r t i n g K e y$ subroutine component in Fig. 2. This results for the time complexity of all these algorithms to be similar. This is true because with efficient implementation of the data structures, the $S o r t i n g K e y$ has the same time complexity of $O (1)$ in all of the cases. Therefore to obtain the time complexity of all the three subroutines, we need only to obtain the time complexity of the subroutine in Fig. 1.

The time complexity of the algorithm will depend on the actual implementation of the data structures which is as follows. In the implementation, we assume we populate these data structures at the point in the algorithm where $t$ is assigned which will take $O (1)$ time. We keep the following hash tables:

Time stamps to list of vehicles: $H_{1} : t \mapsto V$
2-tuples of current node time stamps and next nodes to list of vehicles: $H_{2} : (t, N) \mapsto V$ .
Nodes to the list of time stamps: $H_{3} : t \mapsto (t, N)$

The most time consuming operations is step 22 in Fig. 1 which takes $O (q)$ where $q$ is the total number of time stamps. Assuming $D$ is the degree of the underlying graph, considering the outer loops, the total time spent on this operation is $O (q^{2} D n)$ where $n$ is the number of vehicles.

If we make the further assumption that the length of each path is constant, the worst case complexity of both the baseline and the heuristic algorithm is simplified to $O (n^{3})$ .

Vi Numerical Results

In this section, we compare the performance of our heuristic algorithm DEADLINE & PROXIMITY to our baseline algorithm PROXIMITY. Additionally, for the smaller cases, We compare the results from both these algorithms to the exact solution obtained from solving the MIP. We consider three metrics in our comparisons, namely, the number of vehicles, the tightness of the soft deadlines, and the run time of the algorithms.

In our setup, we create uniformly at random pairs of source and destinations and calculate the shortest paths on the grid like graph $G$ as shown in Fig 3. We use the following parameters.

Separation gap $s_{j_{1}, j_{2}}^{i_{1}, i_{2}} = 5$ for any $j_{1}, j_{2}, i_{1}, i_{2}$ .
Minimum and maximum times on link $τ_{m i n, j}^{i} = 50$ and $τ_{m a x, j}^{i} = + \infty$ for all $i, j$ .
Hard deadlines $d_{j}^{'} = 2.2 q_{j} τ_{m i n, j}$ for each $j$ .
Trip request time $ρ_{j} = 0$ for each $j$ .

For our setup we used Gurobi optimization engine version 8.1.1 running on Microsoft Surface Pro 5 with 8GB RAM and 4 Intel(R) Core(TM) i5-7300U CPUs clocking at 2.60GHz. A Gurobi Python 3.6 binding was used to solve the MIP exactly. Also, we implemented the baseline and the heuristic algorithm in Python 3.6.

We create $20$ instances of VSP with four different vehicle counts; 25, 50, 75, and 100. For each instance, we experiment with varying levels of tightness of the soft deadline. The fraction of missed deadlines corresponding to each deadline value are reported in Fig. 4. The worst run time over all deadlines for each number of vehicles is reported in Fig. 6 for the baseline and the heuristic algorithms.

For 25 vehicles, Fig. (a)a shows the results comparing the percentage of missed deadlines for our heuristic algorithm, the baseline, and the exact solution from MIP. Given the small difference between the result from the baseline algorithm and the exact solution, it is plausible to infer the baseline algorithm is in fact a very effective one in producing schedules with a few number of missed deadlines.

In the case of 25 vehicles, we are able to solve most of the MIP instances exactly in a reasonable amount of time (less than 1 hour). Since The MIP quickly becomes intractable with increasing the number of vehicles; the 25 vehicles is about the maximum number of vehicles that can be used in our test. The comparison between the run time of our heuristic algorithm to the MIP instance solved by Gurobi is reported in Fig. 5 on a logarithmic scale. In most cases, our algorithm is between 1 to 3 orders of magnitude faster, despite the fact that our heuristic algorithm is implemented in notoriously slow Python.

Finally, Fig. 6 shows a comparison between the run time of our heuristic algorithm and the baseline algorithm.

Fig. 3: Underlying graph for simulation is a 5x5 grid like graph. Each edge represent a bidirectional path with dedicated lanes for each direction.

Fig. 5: This figure shows the run time results of our heuristic algorithm compared to the MIP solver in logarithmic scale for 20 random instances. Each value represents the average of worst run time among various levels of tightness of soft deadlines. These deadline values are similar to those in Fig. (a)a. Each of these instances utilize 25 vehicles. The red bars which all happen to have a value greater than 1 are the run time from MIP solver and the blue bars under the grid line for 1 are the run time from our heuristic algorithm. As can be seen, in most cases, our algorithm implemented in Python is between 1 to 3 orders of magnitude faster.

Fig. 6: This figure shows the average taken over 20 samples of the worst run time among varying levels of soft deadlines. The value of soft deadlines in our test are the same as those appearing in Fig. 4. The chart shows how the run time is affected by increasing the number of vehicles from 25 to 100. The square markers represent results from our heuristic algorithm while the circle markers represent the baseline results.

Vii Discussion and future work

In this work, we assumed the route for each vehicle is fixed. There are scenarios where this might make sense for example when some UAV companies are allocated various paths in the airspace by the government and all the scheduling must be performed over these preallocated paths. However, in absence of these kind of limitations, an interesting problem to consider for future research is the joint optimization of routing and scheduling.

Another simplified aspect of the problem is the assumption that each link has unlimited capacity for holding vehicles. This is not entirely without merit as the in-flow and out-flow are bounded by various constraints. However, it might be plausible to set a direct capacity limit on a link, especially when the minimum permitted velocity on a link is $0$ .

With minor modifications, it is possible to expand the DEADLINE & PROXIMITY algorithm and the baseline PROXIMITY to the dynamic VSP to make it more applicable to the real word. It is interesting to see how these two algorithms will compare in that case.

In our numerical result section, we demonstrated for some special cases the result from our heuristic algorithm. It will be interesting to explore more cases, such as when the trip request times are arbitrary and the minimum speed for vehicles can be more than 0.

A limitation of our work is that in our heuristics algorithm DEADLINE & PROXIMITY, the access rule is based on first the proximity of the vehicles to the intersections and only then the deadlines are used as a tie breaking mechanism. In our setup, the time stamps from the created schedules were all a multiple of an integer (in our case, 5), allowing the tie breaking rule a chance to have an influence. In practice, the tie breaking will likely never be used as the odds of having two vehicles at the exact same distance (up to our measurement digital precision) is close to 0. In other words, in presence of noise, etc., our heuristic algorithm degrades to the baseline algorithm. A simple fix is to use a window of a certain size inside which the deadline is the deciding rule. However, to determine the optimal window size will be the subject of a future work.

Another question with regard to both the baseline and the heuristic algorithms is how irregular sizes for the links will affect the quality of the created schedules. For example, a vehicle might be an intersection away from an intersection of interest, and only a very short distance away. But it will get a lower priority compared to a further away vehicle which is already on a connected link to the intersection. It is an interesting line of research to pursue expanding the pool of eligible vehicles in deciding the right of way to include vehicles such as the one in the example above.

Finally, there is an approximation algorithm that is used for Job Shop Scheduling known as Shifting Bottleneck as first appeared in the seminal work [1]. The goal was to minimize the makespan (completion time of the last job to finish). The algorithm works by sequencing each machine as a one machine optimization problem which can be solved efficiently. At any point, a list of sequenced machines and a list of unsequenced machines exists. Based on some criteria about which machine is the biggest next bottlenecks, the unsequenced machines are ranked and the machine with the highest rank is chosen to be sequenced next. Based on the results, the already sequenced machines are resequenced one by one till no further improvements can be found in their schedule. Again, based on the outcome of this step, and according to the bottleneck criteria the next machine is chosen and the process is repeated till all the machines are sequenced. In our context, it is an interesting venue for research to see if any algorithm with a similar idea of detecting the bottleneck vehicles or the bottleneck nodes or even a set of bottleneck neighboring nodes (similar to a zone) can be used to give better schedules.

Viii Conclusion

In this work we introduced a new scheduling problem called Vehicle Scheduling Problem. Given a path between a pair of source and destination for each vehicle over a graph, the goal is to minimize some objective function such as the number of tardy vehicles (i.e. missed deadlines) subject to various constraints as follows. This includes, maintaining a safety time gap at conflicting nodes and meeting hard deadlines after trips are requested by vehicles. Furthermore, each vehicle is required to maintain its speed in an allowable range over any link. We established the NP-hardness of VSP for all commonly used objective functions in the context of JSP. Then, we formulate this problem in terms of a Mixed Integer Linear Programming where the chosen objective function is the number of tardy vehicles. For the case of simultaneous trip requests, we then devised a heuristic algorithm based on giving priority to vehicles closer to an intersection and with less slack time left. We also devised a baseline algorithm that mimics to some extent the real world traffic, i.e. vehicles closer to an intersection will get there first. We then performed numerical experiments on random instances of the problem over a grid like graph to compare the obtained objective value from the exact solution to the MIP formulation as well as the baseline algorithm and our algorithm.

Acknowledgment

We would like to thank Stephen Smith for fruitful discussions on the subject.

References

[1] J. Adams, E. Balas, and D. Zawack (1988) The shifting bottleneck procedure for job shop scheduling. Management science 34 (3), pp. 391–401. Cited by: §VII.
[2] C. Allignol, N. Barnier, P. Flener, and J. Pearson (2012) Constraint programming for air traffic management: a survey 1: in memory of pascal brisset.
The Knowledge Engineering Review
27 (3), pp. 361–392. Cited by: §I.
[3] J. Cordeau, P. Toth, and D. Vigo (1998) A survey of optimization models for train routing and scheduling. Transportation science 32 (4), pp. 380–404. Cited by: §I.
[4] W. Fang, S. Yang, and X. Yao (2015) A survey on problem models and solution approaches to rescheduling in railway networks. IEEE Transactions on Intelligent Transportation Systems 16 (6), pp. 2997–3016. Cited by: §I.
[5] M. Gharibi, R. Boutaba, and S. L. Waslander (2016) Internet of drones. IEEE Access 4, pp. 1148–1162. Cited by: §I.
[6] J. Hurink and S. Knust (2005) Tabu search algorithms for job-shop problems with a single transport robot. European journal of operational research 162 (1), pp. 99–111. Cited by: §I.
[7] S. Knust (2000) Shop-scheduling problems with transportation. Cited by: §I.
[8] S. A. Kravchenko (2000) Minimizing the number of late jobs for the two-machine unit-time job-shop scheduling problem. Discrete Applied Mathematics 98 (3), pp. 209–217. Cited by: §III, §III, §III.
[9] W. Kubiak and V. Timkovsky (1996) Total completion time minimization in two-machine job shops with unit-time operations. European journal of operational research 94 (2), pp. 310–320. Cited by: §III.
[10] J. K. Lenstra and A. R. Kan (1979) Computational complexity of discrete optimization problems. In Annals of Discrete Mathematics, Vol. 4, pp. 121–140. Cited by: §III, §III.
[11] M. Nolan (2010) Fundamentals of air traffic control. Cengage learning. Cited by: §I.
[12] L. L. Peterson and B. S. Davie (2007) Computer networks: a systems approach. Elsevier. Cited by: §I.
[13] M. L. Pinedo (2016) Scheduling: theory, algorithms, and systems. Springer. Cited by: §I, §III.
[14] J. M. Schutten (1998) Practical job shop scheduling. Annals of Operations Research 83, pp. 161–178. Cited by: §I.
[15] V. G. Timkovsky (1998) Is a unit-time job shop not easier than identical parallel machines?. Discrete applied mathematics 85 (2), pp. 149–162. Cited by: §III, §III, §III.
[16] J. Yao and N. Ansari (2019) QoS-aware rechargeable uav trajectory optimization for sensing service. In ICC 2019-2019 IEEE International Conference on Communications (ICC), pp. 1–6. Cited by: §I.

Vehicle Scheduling Problem

Fuzzy Mixed Integer Linear Programming for Air Vehicles Operations Optimization

Heuristic Algorithms for Co-scheduling of Edge Analytics and Routes for UAV Fleet Missions

Minimum Length Scheduling for Full Duplex Time-Critical Wireless Powered Communication Networks

On the Complexity of Scheduling Problems With a Fixed Number of Parallel Identical Machines

Fast and computationally efficient generative adversarial network algorithm for unmanned aerial vehicle-based network coverage optimization

Safety Verification and Control for Collision Avoidance at Road Intersections

Coordinating CAV Swarms at Intersections with a Deep Learning Model

Code Repositories

MDVSP

I Introduction

I-a Our contribution

Ii Problem Definition

Definition II.1 (Vehicle Scheduling Problem (VSP)).

Iii NP-hardness proof

Definition III.1 (GENERALIZED K-MACHINE UNIT JOB SHOP PROBLEM: optimization version).

Theorem 1.

Proof.

Theorem 2.

Proof.

Iv Exact MIP formulation

Iv-a Notations

Iv-B Objective function

Iv-C Constraints

V Scheduling algorithms

V-a Baseline algorithm: PROXIMITY

V-B Heuristic algorithm: DEADLINE & PROXIMITY

V-C Complexity

Vi Numerical Results

Vii Discussion and future work

Viii Conclusion

Acknowledgment

References

Vehicle Scheduling Problem

Related Research

Fuzzy Mixed Integer Linear Programming for Air Vehicles Operations Optimization

Heuristic Algorithms for Co-scheduling of Edge Analytics and Routes for UAV Fleet Missions

Minimum Length Scheduling for Full Duplex Time-Critical Wireless Powered Communication Networks

On the Complexity of Scheduling Problems With a Fixed Number of Parallel Identical Machines

Fast and computationally efficient generative adversarial network algorithm for unmanned aerial vehicle-based network coverage optimization

Safety Verification and Control for Collision Avoidance at Road Intersections

Coordinating CAV Swarms at Intersections with a Deep Learning Model

Code Repositories

MDVSP

I Introduction

I-a Our contribution

Ii Problem Definition

Definition II.1 (Vehicle Scheduling Problem (VSP)).

Iii NP-hardness proof

Definition III.1 (GENERALIZED K-MACHINE UNIT JOB SHOP PROBLEM: optimization version).

Theorem 1.

Proof.

Theorem 2.

Proof.

Iv Exact MIP formulation

Iv-a Notations

Iv-B Objective function

Iv-C Constraints

V Scheduling algorithms

V-a Baseline algorithm: PROXIMITY

V-B Heuristic algorithm: DEADLINE & PROXIMITY

V-C Complexity

Vi Numerical Results

Vii Discussion and future work

Viii Conclusion

Acknowledgment

References