Parallel and Distributed Computing

CSE 4001

Review - 3

Parallelization of Real Time Vehicle Routing

Problem

Project Members

Aryan Prasad 19BCE0697

Aditya B Singh 19BCE2242
Deepanshu Wadhwa 19BCE0174

Submitted to
Prof. Manoov R.

School of Computer Science and Engineering

VIT
Vellore, Tamil Nadu.
Objective

Parallelization of algorithms used to solve Vehicle Routing Problems

Abstract

Vehicle routing problems (VRPs) are integral to logistics management both in the
private and public sectors. It involves determining the correct vehicle routes using
a set of users, subject to additional terms.

In real-time vehicle management, vehicle routes are built impromptu as vehicle

locations, travel times and customer requests are revealed over time. To deal
with such problems, a new generation of fast on-line algorithms are required to
detect uncertainty. Although a few articles on this topic have already been
published, the literature on real-time vehicle routing is still unstructured. In this
paper, is research in this field that has been updated to include some of the
issues that have been neglected so far. Emphasis has been placed on parallel
computing techniques. In this project, the real time vehicle routing algorithm will
be implemented using multi-threading. There are many applications in real time
vehicle routing which would benefit greatly if parallel computation was applied.
Problem Description

The most common operational constraints while solving VRPs are the total
demand carried by a vehicle at any time does not exceed a given capacity, the
total duration of any route is not greater than a predetermined bound, and service
time windows set by customers are respected. In long haul routing, vehicles are
usually assigned one task at a time, while in short-haul routing, tasks are of short
duration (much shorter than a work shift) and a tour that is built through a
sequence of tasks. There exist several important problems that need to be
solved in real-time. Given below are some of the key applications that promote
research in the field of real-time VRPs.

• Dynamic Fleet management

• Vendor managed distribution system
• Courier Service
• Rescue and repair service companies
• Dial a ride
• Emergency service
• Taxi cab service
 Software Requirements

● Anaconda Spyder
● Parallel Python Module
● Pyro library
● Intel's Vtune amplifier (for debugging and fixing performance bottlenecks)
● Datasets to use as test values to simulate real-time situations
(http://vrp-rep.org/datasets.html)

Literature Review

S.no Paper Abstract Conclusion Algorithm Year

Name
1) Using parallel This paper In this paper, the Probabilistic 2011
& distributed focuses on the role of parallel algorithms
computing for Vehicle Routing and
real-time Problem distributed
solving of with Stochastic computing
vehicle routing Demands systems
problems with (VRPSD) and for solving
stochastic discusses combinatorial
demands. how Parallel and optimization
Distributed problems and, in
Computing particular, vehicle
Systems can be routing problems,
employed has been
to efficiently discussed
solve the
VRPSD. Our
approach
deals with
uncertainty in
the customer
demands by
considering
safety stocks,
i.e. when
 designing the
routes, part of
the vehicle
capacity is
reserved to
deal with
potential
emergency
situations
caused by
unexpected
demands. Thus,
for a
given VRPSD
instance,
our algorithm
considers
different levels of
safety
stocks.

2) Parallel and Since its Work in this Serial and 2014

Serial proposal by paper focuses on Parallel
algorithms for Dantzig and generating algorithms
vehicle routing Ramser solutions for the
problem (1959), the VRP. However, it
vehicle routing should be clear
problem (VRP) that our
has been the procedure can
subject of a handle more
a great deal of complex variants
research. of the VRP by
Given customers modifying the
with RRTR algorithm
known locations to account for
and demands, additional
the task is to constraints,
find a minimum because many
cost set of VRP variants can
routes that be modeled as a
satisfies all set-covering
customer problem or set
 demands. partitioning
Additionally, the problem.
vehicles Furthermore, our
assigned to algorithm’s use of
these routes both met heuristic
must carry no solvers and set-
more than a covering solvers
fixed quantity of could be effective
goods and can for other difficult
travel no more combinatorial
than a maximum optimization
distance. problems that
Although many can be
variants of the formulated as a
VRP have been relatively simple
proposed over integer program
the last 50 that permits one
years, even this to quickly
simplest version generate
of the VRP new columns via
remains heuristics.
computationally
difficult.

3) An This paper There are two Heuristic 2014

Optimization addresses a types of algorithms such
Model for the vehicle algorithms as the Genetic
Vehicle scheduling for solving the algorithm and
Routing problem VRP. One is the particle swarm
Problem in encountered in exact algorithm optimization
Multi-product the cold chain and the other is algorithm
Frozen Food logistics of the heuristic
Delivery the frozen food algorithm.
delivery The exact
industry. Unlike algorithm
the includes
single product the branch and
delivery bound method,
scenario, we the cutting plane
propose an method, the
optimization network flow
model that algorithm,
 manages the dynamic
delivery of a programming,
variety of etc.
products. In this As the complexity
scenario, a set of the solution for
of the VRP is NP-
customers make hard, the exact
requests solution can only
for a variety of be used to solve
frozen a
foods which are VRP with a small
being number of
loaded together. distribution points
The
objective is to
find the
routes that
represent the
minimum
delivery cost
for a fleet of
identical
vehicles that,
departing
from a depot,
visiting all
customers only
once and
returning to the
depot.

4) Stochastic The purpose of The paper tries to Parallel 2014

Vehicle this paper assess more than algorithm
Routing is to develop 3000
Problem: A structural bibliographical
Literature classification of entities and
Survey Stochastic identified 49
Vehicle articles related to
Routing Problem SVRP. The
(SVRP) bibliographical
by different entities were
domains and selected from
attributes. This various sources
research published since
used a 1963 and
systematic classified
review based on 8
and different domains
meta-analysis on and 29 attributes.
SVRP The classification
literatures. This has been
includes demonstrated to
browsing be
relevant robust enough to
researches and incorporate a
publications, diverse set of
screening SVRP literatures
related articles, which were
identifying previously
domains, published as well
attributes and as those
categorizing the expected
articles in the future.
based on the However, there is
identified no taxonomy that
domains and remaindered a
attributes.
The findings of
the study
show clear
differences on
the number of
studies
under each
domain and
attribute. Most
studied
attributes are
stochastic
customer
demand,
capacitated
vehicle,
synthesis data
 and
objective
function with
cost
minimization.
Whereas the
least studied
are maximization
objective
function,
stochastic
service time,
and an applied
model using
stochastic with
recurs.

5) Improved This paper The bee colony AI algorithms 2011

artificial bee investigates a algorithm is well
colony well-known studied and
algorithm for complex understood such
vehicle routing combinatorial that the paper
problem with problem could be used for
time windows. known as the further research
vehicle purpose
routing problem
with time
windows
(VRPTW).
Unlike the
standard
vehicle routing
problem,
each customer
in the
VRPTW is
served within
a given time
constraint.
This paper
solves the
VRPTW using
an
improved
artificial bee
colony (IABC)
algorithm.
The
performance of
this
algorithm is
improved by
a local
optimization
based
on a crossover
operation
and a scanning
strategy.
Finally, the
effectiveness of
the IABC is
evaluated
on some
well-known
benchmarks.
The results
demonstrate the
power of
IABC algorithm
in
solving the
VRPTW.
Implementation Details

We tried optimizing the VRP algorithm by combining the ideas of Improved

artificial bee colony paper and Parallel and Serial algorithms for vehicle routing
problem paper to get what we think is the best algorithm possible in terms of time
complexity.

Given a graph and a source vertex in the graph, we find shortest paths from
source to all vertices in the given graph.
For this project we will use Dijkstra's algorithm, but implement it in a way which
takes all the constraints regarding VRP in consideration.
Dijkstra’s algorithm involves creating a minimum spanning tree. Like Prim’s MST,
we generate a SPT (shortest path tree) with a given source as the root. We
maintain two sets, one set contains vertices included in the shortest path tree,
and another set includes vertices not yet included in the shortest path tree. At
every step of the algorithm, we find a vertex which is in the other set (set of not
yet included) and has a minimum distance from the source.

Below are the detailed steps we will use to VRP

Algorithm

1) Create a set called the shortest path tree set (sptSet) that keeps track of
vertices included in shortest path tree, i.e., whose minimum distance from source
is calculated and finalized.
2) Assign INFINITE value to all vertices in the input graph. Assign the distance
value for source vertex as 0
3) While the Set doesn’t include all vertices
a) pick any vertex u which is not in shortest path tree set and having
minimum distance value.
b) Add u to sptSet.
c) Update distance value of all adjacent vertices of u. To update the
distance values, iterate through all adjacent vertices. For every adjacent vertex v,
if the sum of distance value of u (from source) and weight of edge u-v, is less
than the distance value of v, then update the distance value of v.
Serial Code

from __future__ import print_function

from collections import namedtuple
from six.moves import xrange
from ortools.constraint_solver import pywrapcp
from ortools.constraint_solver import routing_enums_pb2
import time

###########################
# Problem Data Definition #
###########################
# Vehicle declaration
Vehicle = namedtuple('Vehicle', ['capacity'])
# City block declaration
CityBlock = namedtuple('CityBlock', ['width', 'height'])
class DataProblem():
"""Stores the data for the problem"""
def __init__(self):
"""Initializes the data for the problem"""
# Locations in block unit
locations = \
[(4, 4), # depot
(2, 0), (8, 0), # order location
(0, 1), (1, 1),
(5, 2), (7, 2),
(3, 3), (6, 3),
(5, 5), (8, 5),
(1, 6), (2, 6),
(3, 7), (6, 7),
(0, 8), (7, 8)]
# Compute locations in meters using the block dimensiondefined as follow
# Manhattan average block: 750ft x 264ft -> 228m x 80m
# here we use: 114m x 80m city block
city_block = CityBlock(width=228 / 2, height=80)
 self._locations = [(loc[0] * city_block.width, loc[1] *city_block.height) for loc
in locations]
self._demands = \
[0, # depot
1, 1, # 1, 2
2, 4, # 3, 4
2, 4, # 5, 6
8, 8, # 7, 8
1, 2, # 9,10
1, 2, # 11,12
4, 4, # 13, 14
8, 8] # 15, 16

@property
def vehicle(self):
"""Gets a vehicle"""
return Vehicle(capacity=15)
@property
def num_vehicles(self):
"""Gets number of vehicles"""
return 4
@property
def locations(self):
"""Gets locations"""
return self._locations
@property
def num_locations(self):
"""Gets number of locations"""
return len(self.locations)
@property
def depot(self):
"""Gets depot location index"""
return 0
@property
def demands(self):
"""Gets demands at each location"""
return self._demands
#######################
# Problem Constraints #
#######################
def manhattan_distance(position_1, position_2):
"""Computes the Manhattan distance between two points"""
return (abs(position_1[0] - position_2[0]) + abs(position_1[1] - position_2[1]))

class CreateDistanceEvaluator(object): # pylint:disable=too-few-public-methods

"""Creates callback to return distance between points."""
def __init__(self, data):
"""Initializes the distance matrix."""
self._distances = {}
# precompute distance between location to have distance callback in O(1)
for from_node in xrange(data.num_locations):
self._distances[from_node] = {}
for to_node in xrange(data.num_locations):
if from_node == to_node:
self._distances[from_node][to_node] = 0
else:
self._distances[from_node][to_node] =
(manhattan_distance(data.locations[from_node],data.locations[to_node]))

def distance_evaluator(self, from_node, to_node):

"""Returns the manhattan distance between the two nodes"""
return self._distances[from_node][to_node]

class CreateDemandEvaluator(object):
 # pylint:disable=too-few-public-methods
"""Creates callback to get demands at each location."""
def __init__(self, data):
"""Initializes the demand array."""
self._demands = data.demands

def demand_evaluator(self, from_node, to_node):

"""Returns the demand of the current node"""
del to_node
return self._demands[from_node]

def add_capacity_constraints(routing, data, demand_evaluator):

"""Adds capacity constraint"""
capacity = 'Capacity'
routing.AddDimension(
demand_evaluator,
0,
# null capacity slack
data.vehicle.capacity,
True,
# start cumul to zero
capacity)

###########
# Printer #
###########
def print_solution(data, routing, assignment):
"""Prints assignment on console"""
print('Objective: {}'.format(assignment.ObjectiveValue()))
total_distance = 0
total_load = 0
capacity_dimension = routing.GetDimensionOrDie('Capacity')
for vehicle_id in xrange(data.num_vehicles):
 index = routing.Start(vehicle_id)
plan_output = 'Route for vehicle {}:\n'.format(vehicle_id)
distance = 0
while not routing.IsEnd(index):
load_var = capacity_dimension.CumulVar(index)
plan_output += ' {} Load({}) -> '.format(
routing.IndexToNode(index),
assignment.Value(load_var))
previous_index = index
index = assignment.Value(routing.NextVar(index))
distance += routing.GetArcCostForVehicle(previous_index, index,
vehicle_id)
load_var = capacity_dimension.CumulVar(index)
plan_output += ' {0} Load({1})\n'.format(
routing.IndexToNode(index),
assignment.Value(load_var))
plan_output += 'Distance of the route: {}m\n'.format(distance)
plan_output += 'Load of the route:
{}\n'.format(assignment.Value(load_var))
print(plan_output)
total_distance += distance
total_load += assignment.Value(load_var)
print('Total Distance of all routes: {}m'.format(total_distance))
print('Total Load of all routes: {}'.format(total_load))

########
# Main #
########
def main():
"""Entry point of the program"""
# Instantiate the data problem.
data = DataProblem()
# Create Routing Model
 routing =
pywrapcp.RoutingModel(data.num_locations,data.num_vehicles,data.depot)
# Define weight of each edge
distance_evaluator =CreateDistanceEvaluator(data).distance_evaluator
routing.SetArcCostEvaluatorOfAllVehicles(distance_evaluator)
# Add Capacity constraint
demand_evaluator = CreateDemandEvaluator(data).demand_evaluator
add_capacity_constraints(routing, data, demand_evaluator)
# Setting first solution heuristic (cheapest addition).
search_parameters = pywrapcp.RoutingModel.DefaultSearchParameters()
search_parameters.first_solution_strategy =
(routing_enums_pb2.FirstSolutionStrategy.PATH_CHEAPEST_ARC)
# pylint: disable=no-member
# Solve the problem.
assignment =routing.SolveWithParameters(search_parameters)
print_solution(data, routing, assignment)

if __name__ == '__main__':
tic = time.perf_counter()

main()
toc = time.perf_counter()

print(f"Took {toc - tic:0.4f} seconds")

Output
Parallel Code

"""Capacitated Vehicle Routing Problem with Time Windows (CVRPTW).

"""
from __future__ import print_function
from six.moves import xrange
from ortools.constraint_solver import pywrapcp
from ortools.constraint_solver import routing_enums_pb2

###########################
# Problem Data Definition #
###########################

class Vehicle():
"""Stores the property of a vehicle"""
def __init__(self):
"""Initializes the vehicle properties"""
self._capacity = 15
# Travel speed: 5km/h to convert in m/min
self._speed = 5 * 60 / 3.6
@property
def capacity(self):
"""Gets vehicle capacity"""
return self._capacity
@property
def speed(self):
"""Gets the average travel speed of a vehicle"""
return self._speed

class CityBlock():
"""City block definition"""
@property
def width(self):
"""Gets Block size West to East"""
 return 228/2
@property
def height(self):
"""Gets Block size North to South"""
return 80

class DataProblem():
"""Stores the data for the problem"""
def __init__(self):
"""Initializes the data for the problem"""
self._vehicle = Vehicle()
self._num_vehicles = 4
# Locations in block unit
locations = \
[(4, 4), # depot
(2, 0), (8, 0), # row 0
(0, 1), (1, 1),
(5, 2), (7, 2),
(3, 3), (6, 3),
(5, 5), (8, 5),
(1, 6), (2, 6),
(3, 7), (6, 7),
(0, 8), (7, 8)]
# locations in meters using the city block dimension
city_block = CityBlock()
self._locations = [(loc[0]*city_block.width,loc[1]*city_block.height) for loc in
locations]
self._depot = 0
self._demands = \
[0, # depot
1, 1, # 1, 2
2, 4, # 3, 4
2, 4, # 5, 6
8, 8, # 7, 8
1, 2, # 9,10
 1, 2, # 11,12
4, 4, # 13, 14
8, 8] # 15, 16
self._time_windows = \
[(0, 0),
(75, 85), (75, 85), # 1, 2
(60, 70), (45, 55), # 3, 4
(0, 8), (50, 60), # 5, 6
(0, 10), (10, 20), # 7, 8
(0, 10), (75, 85), # 9, 10
(85, 95), (5, 15), # 11, 12
(15, 25), (10, 20), # 13, 14
(45, 55), (30, 40)] # 15, 16
@property
def vehicle(self):
"""Gets a vehicle"""
return self._vehicle
@property
def num_vehicles(self):
"""Gets number of vehicles"""
return self._num_vehicles
@property
def locations(self):
"""Gets locations"""
return self._locations
@property
def num_locations(self):
"""Gets number of locations"""
return len(self.locations)
@property
def depot(self):
"""Gets depot location index"""
return self._depot
@property
def demands(self):
"""Gets demands at each location"""
return self._demands
 @property
def time_per_demand_unit(self):
"""Gets the time (in min) to load a demand"""
return 5 # 5 minutes/unit
@property
def time_windows(self):
"""Gets (start time, end time) for each locations"""
return self._time_windows

#######################
# Problem Constraints #
#######################
def manhattan_distance(position_1, position_2):
"""Computes the Manhattan distance between two points"""
return (abs(position_1[0] - position_2[0]) + abs(position_1[1] -
position_2[1]))

class CreateDistanceEvaluator(object):
"""Creates callback to return distance between points."""
def __init__(self, data):
"""Initializes the distance matrix."""
self._distances = {}
# precompute distance between location to have distance
callback in O(1)
for from_node in xrange(data.num_locations):
self._distances[from_node] = {}
for to_node in xrange(data.num_locations):
if from_node == to_node:
self._distances[from_node][to_node] = 0
else:
self._distances[from_node][to_node] =
(manhattan_distance(data.locations[from_node],data.locations[to_node]))

def distance_evaluator(self, from_node, to_node):

"""Returns the manhattan distance between the two nodes"""
 return self._distances[from_node][to_node]

class CreateDemandEvaluator(object):
"""Creates callback to get demands at each location."""
def __init__(self, data):
"""Initializes the demand array."""
self._demands = data.demands
def demand_evaluator(self, from_node, to_node):
"""Returns the demand of the current node"""
del to_node
return self._demands[from_node]
def add_capacity_constraints(routing, data, demand_evaluator):
"""Adds capacity constraint"""
capacity = "Capacity"
routing.AddDimension(
demand_evaluator,
0, # null capacity slack
data.vehicle.capacity, # vehicle maximum capacity
True, # start cumul to zero
capacity)

class CreateTimeEvaluator(object):
"""Creates callback to get total times between locations."""
@staticmethod
def service_time(data, node):
"""Gets the service time for the specified location."""
return data.demands[node] * data.time_per_demand_unit
@staticmethod
def travel_time(data, from_node, to_node):
"""Gets the travel times between two locations."""
if from_node == to_node:
travel_time = 0
else:
 travel_time =
manhattan_distance(data.locations[from_node],data.locations[to_node]) /
data.vehicle.speed
return travel_time
def __init__(self, data):
"""Initializes the total time matrix."""
self._total_time = {}
# precompute total time to have time callback in O(1)
for from_node in xrange(data.num_locations):
self._total_time[from_node] = {}
for to_node in xrange(data.num_locations):
if from_node == to_node:
self._total_time[from_node][to_node] = 0
else:
self._total_time[from_node][to_node] =
int(self.service_time(data, from_node) + self.travel_time(data, from_node,
to_node))
def time_evaluator(self, from_node, to_node):
"""Returns the total time between the two nodes"""
return self._total_time[from_node][to_node]
def add_time_window_constraints(routing, data, time_evaluator):
"""Add Global Span constraint"""
time = "Time"
horizon = 120
routing.AddDimension(
time_evaluator,
horizon, # allow waiting time
horizon, # maximum time per vehicle
False, # don't force start cumul to zero since we are giving TW to start
nodes
time)
time_dimension = routing.GetDimensionOrDie(time)
for location_idx, time_window in enumerate(data.time_windows):
if location_idx == 0:
continue
index = routing.NodeToIndex(location_idx)
time_dimension.CumulVar(index).SetRange(time_window[0],
 time_window[1])
routing.AddToAssignment(time_dimension.SlackVar(index))
for vehicle_id in xrange(data.num_vehicles):
index = routing.Start(vehicle_id)

time_dimension.CumulVar(index).SetRange(data.time_windows[0][0],data.time_
windows[0][1])
routing.AddToAssignment(time_dimension.SlackVar(index))

###########
# Printer #
###########
class ConsolePrinter():
"""Print solution to console"""
def __init__(self, data, routing, assignment):
"""Initializes the printer"""
self._data = data
self._routing = routing
self._assignment = assignment
@property
def data(self):
"""Gets problem data"""
return self._data
@property
def routing(self):
"""Gets routing model"""
return self._routing
@property
def assignment(self):
"""Gets routing model"""
return self._assignment
def print(self):
"""Prints assignment on console"""
# Inspect solution.
capacity_dimension = self.routing.GetDimensionOrDie('Capacity')
 time_dimension = self.routing.GetDimensionOrDie('Time')
total_dist = 0
total_time = 0
for vehicle_id in xrange(self.data.num_vehicles):
index = self.routing.Start(vehicle_id)
plan_output = 'Route for vehicle{0}:\n'.format(vehicle_id)
route_dist = 0
while not self.routing.IsEnd(index):
node_index = self.routing.IndexToNode(index)
next_node_index = self.routing.IndexToNode(
self.assignment.Value(self.routing.NextVar(index)))
route_dist += manhattan_distance(
self.data.locations[node_index],
self.data.locations[next_node_index])
load_var = capacity_dimension.CumulVar(index)
route_load = self.assignment.Value(load_var)
time_var = time_dimension.CumulVar(index)
time_min = self.assignment.Min(time_var)
time_max = self.assignment.Max(time_var)
slack_var = time_dimension.SlackVar(index)
slack_min = self.assignment.Min(slack_var)
slack_max = self.assignment.Max(slack_var)
plan_output += ' {0} Load({1}) Time({2},{3})Slack({4},{5})
->'.format(node_index,route_load,time_min, time_max,slack_min, slack_max)
index =self.assignment.Value(self.routing.NextVar(index))
node_index = self.routing.IndexToNode(index)
load_var = capacity_dimension.CumulVar(index)
route_load = self.assignment.Value(load_var)
time_var = time_dimension.CumulVar(index)
route_time = self.assignment.Value(time_var)
time_min = self.assignment.Min(time_var)
time_max = self.assignment.Max(time_var)
total_dist += route_dist
total_time += route_time
plan_output += ' {0} Load({1})Time({2},{3})\n'.format(node_index,
route_load, time_min, time_max)
plan_output += 'Distance of the route:{0}m\n'.format(route_dist)
 plan_output += 'Load of the route:{0}\n'.format(route_load)
plan_output += 'Time of the route:{0}min\n'.format(route_time)
print(plan_output)
print('Total Distance of all routes:{0}m'.format(total_dist))
print('Total Time of all routes: {0}min'.format(total_time))

########
# Main #
########
def main():
"""Entry point of the program"""
# Instantiate the data problem.
data = DataProblem()
# Create Routing Model
routing = pywrapcp.RoutingModel(data.num_locations,
data.num_vehicles, data.depot)
# Define weight of each edge
distance_evaluator = CreateDistanceEvaluator(data).distance_evaluator
routing.SetArcCostEvaluatorOfAllVehicles(distance_evaluator)
# Add Capacity constraint
demand_evaluator = CreateDemandEvaluator(data).demand_evaluator
add_capacity_constraints(routing, data, demand_evaluator)
# Add Time Window constraint
time_evaluator = CreateTimeEvaluator(data).time_evaluator
add_time_window_constraints(routing, data, time_evaluator)
# Setting first solution heuristic (cheapest addition).
search_parameters =pywrapcp.RoutingModel.DefaultSearchParameters()
search_parameters.first_solution_strategy = (
routing_enums_pb2.FirstSolutionStrategy.PATH_CHEAPEST_ARC)
# Solve the problem.
assignment = routing.SolveWithParameters(search_parameters)
printer = ConsolePrinter(data, routing, assignment)
printer.print()

if __name__ == '__main__':
 tic = time.perf_counter()

main()
toc = time.perf_counter()

print(f"Took {toc - tic:0.4f} seconds")

Output
Result Obtained

Parallel Implementation Serial Implementation

3.46 sec 5.34 sec
3.22 sec 5.22 sec
2.98 sec 5.19 sec
3.71 sec 5.58 sec
3.45 sec 4.98 sec

Conclusion

In recent times, a lot of literature has been devoted to VRPs. For further scope
and advancement in solving VRPs, research work in the future may be directed
towards some of the issues presented ahead.
One issue that can be looked upon in the future is adding capabilities in
heuristics for future predictions to handle current requests optimally not only with
respect to current timestamp but in such a way that future demands can also be
serviced near- optimally. Routing and dispatching problems pertaining to varying
travel durations in real-time can also be looked upon which might help in the
development of intelligent transportation systems. VRPs related to emergency
services are also a vast area of research as their implications and impacts are
global. Finally, automated guided vehicle routing and dispatching problems,
which mostly are observed in port terminals and in manufacturing plants, can be
addressed. The results obtained on parallel python are more time constraint and
has a better result.
References
[1] Juan, A. A., Faulin, J., Jorba, J., Caceres, J., & Marquès, J. M. (2011).
Using parallel & distributed computing for real-time solving of vehicle
routing problems with stochastic demands. Annals of Operations Research,
207(1), 43–65. doi:10.1007/s10479-011-0918-z

[2] C. I. Hsu et al., “Optimal delivery cycles for joint distribution of

multi-temperature food,” Food Control, vol. 34, no.1, pp. 106-114, 2013.
54

[3] W. B. Hu, “A hybrid chaos-particle swarm optimization algorithm for the

vehicle routing problem with time window,” Entropy, vol. 15, no.4, pp. 1247-
1270, 2013

[4] Y. Jin and Y. Z. Ding, “Research on VRPTW model with the restricts of
both weight and volume,” Logistics Technology, vol. 32, no.4, pp. 53-56,
2009.

[5] G. Zhao and Y. F. Zhang, “On the cold chain logistics routing
optimization,” in 30th Chinese Control Conference, Yantai, People’s Republic
Of China, 2011, pp. 2063-2068.

[6] M. Solomon, “Algorithms for the Vehicle Routing and Scheduling Problem
with Time Window Constraints,” Operations Research, Vol. 35, No. 2, 1987, pp.
254-265.doi:10.1287/opre.35.2.254

[7] F. M. Andres, “An Iterative Route Construction and Improvement Algorithm

for the Vehicle Routing Problem with Soft Time Windows,” Transportation
Research Part B, Vol. 43, No. 4, 2010, pp.438-447.

[8] P. Toth and D. Vigo, “An Overview of Vehicle Routing Problems,” SIAM
Monographs on Discrete Mathematics and Applications, 2002,
pp.1-26.doi:10.1137/1.9780898718515.ch1

[9] R. Baldacci, E. Hadjiconstantinou and A. Mingozzi, “An Exact Algorithm

for the Capacitated Vehicle Routing Problem Based on a Two-Commodity Network
Flow Formulation,” Operations Research, Vol. 52, No. 5, 2004, pp. 723- 738.
doi:10.1287/opre.1040.0111

[10] M.L. Balinski and R.E. Quandt (1964): On an Integer Program for a
Delivery Problem. Operations Research 12, 300–30

[11] U. Blasum and W. Hochst ̈attler (2000): Application of the Branch and Cut
Method to the Vehicle Routing Problem. Zentrum f ̈ur Angewandte Informatik,
K ̈oln, Technical Report zpr2000-386

[12] V. Campos,A. Corber ́an, and E. Mota (1991): Polyhedral Results for
aVehicle Routing Problem. European Journal of Operations Research 52, 75–85

[13] N. Christofides and S. Eilon (1969): An Algorithm for the Vehicle

Dispatching Problem. Operational Research Quarterly 20, 309–318

[14] N. Christofides, A. Mingozzi and P. Toth (1981): Exact Algorithms for

Solving the Vehicle Routing Problem Based on Spanning Trees and Shortest Path
Relaxations. Mathematical Programming 20, 255–282

[15] G. Cornu ́ejols and F. Harche (1993): Polyhedral Study of the Capacitated
Vehicle Routing Problem. Mathematical Programming 60, 21–52

[16] F.H. Cullen, J.J. Jarvis and H.D. Ratliff (1981): Set Partitioning Based
Heuristic for Interactive Routing. Networks 11, 125–144

[17] G.B. Dantzig and R.H. Ramser (1959): The Truck Dispatching Problem.
Management Science 6, 80–9155

[18] M.L. Fisher (1988): Optimal Solution of Vehicle Routine Problems Using
Minimum k-Trees. Operations Research 42, 626–642

[19] M.L. Fisher and R. Jaikumar (1981): A Generalized Assignment Heuristic

for Solving the VRP. Networks 11, 109–124

[20] B.A. Foster and D.M. Ryan (1976): An Integer Programming Approach to the
Vehicle Scheduling Problem. Operational Research Quarterly 27, 367–384

[21] M.R. Garey and D.S. Johnson (1979): Computers and Intractability: A
Guide to the Theory of NP-Completeness. W.H. Freeman and Co., San Francisco

[22] M. Held and R.M. Karp (1969): The Traveling Salesman Problem and Minimal
Spanning Trees. Operations Research 18, 1138–1162

[23] L. Kopman (1999): A New Generic Separation Routine and Its Application
in a Branch and Cut Algorithm for the Vehicle Routing Problem. Ph.D
Dissertation, Field of Operations Research, Cornell University, Ithaca, NY,
USA

[24] L. Lad ́anyi (1996): Parallel Branch and Cut and Its Application to the
Traveling Salesman Problem. Ph.D. Dissertation, Field of Operations Research,
Cornell University, Ithaca, NY, USA

[25] L. Lad ́anyi, T.K. Ralphs, and L.E. Trotter (2001): Branch, Cut, and
Price: Sequential and Parallel. Computational Combinatorial Optimization, D.
Naddef and M. J ̈unger, eds., Springer, Berlin, 223–260

[26] https://pythonhosted.org/Pyro/

[27] https://pythonhosted.org/Pyro/1-intro.html

[28] https://www.geeksforgeeks.org/dijkstras-shortest-path-algorithm-greedy-algo-7/