Skip to content

Shortest path problems

Author: Achyuthuni Sri Harsha
Shortest path is one problem in networks which appears in many forms across many industries. It tells the user how to find the shortest path between two pair of nodes. In this particular example, we will look at finding the shortest path between a pair of nodes in a directed network using an integer programming solver.

import networkx as nx

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

Consider the following simple weighted directed network, with four nodes and five edges.

edgelist_df = pd.DataFrame({'node1':['s', 's', 'u', 'u', 'v'], 'node2':['u', 'v', 'v', 't', 't'], 
                            'weights':[3, 2, 0.7, 1, 7]
                           })
edgelist_df
node1 node2 weights
0 s u 3.0
1 s v 2.0
2 u v 0.7
3 u t 1.0
4 v t 7.0
g = nx.DiGraph()
for i, elrow in edgelist_df.iterrows():
    g.add_edge(elrow[0], elrow[1], weight=elrow[2])
g.edges(data=True)
OutEdgeDataView([('s', 'u', {'weight': 3.0}), ('s', 'v', {'weight': 2.0}), ('u', 'v', {'weight': 0.7}), ('u', 't', {'weight': 1.0}), ('v', 't', {'weight': 7.0})])
# for each node we are trying to fix the coordinates
g.add_node('s',pos=(0,1))
g.add_node('u',pos=(1,2))
g.add_node('v',pos=(1,0))
g.add_node('t',pos=(2,1))
g.nodes(data=True)
NodeDataView({'s': {'pos': (0, 1)}, 'u': {'pos': (1, 2)}, 'v': {'pos': (1, 0)}, 't': {'pos': (2, 1)}})
# This function gets the coordinates for nodes
pos = nx.get_node_attributes(g,'pos')

# This function gets the weights for the edges 
weight = nx.get_edge_attributes(g,'weight')


nx.draw(g,pos, with_labels=True)
nx.draw_networkx_edge_labels(g,pos,edge_labels = weight)
plt.show()

png

Now, we want to find the shortest path between the node 's' and 't'. In this network, edge-weights represent the costs for each edge. The weights could be distance, or time. NetworkX has an inbuilt function shortest_path which returs the shortest path. Using networkX, we get the following shortest path:

path_2_0 = nx.shortest_path(g, source ='s',target = 't')
path_2_0
['s', 'u', 't']

Formulating the problem using integer programming

We have n nodes V and m edges E (n=4, m=5 for this example). OR tools is an open source software built by Google for solving integer programming problems. Cp-Sat solver is one such model by OR Tools, which we are going to use today.

We can use binary decision variables \(edge_{i,j}\) representing the edge that goes from node i to node j. If \(edge_{i,j}=1\) the shortest path belongs to the path between i and j, 0 otherwise.

from ortools.sat.python import cp_model
shortest_path_model = cp_model.CpModel()
# Creating one integer decision variable for each edge
edge_bool_vars = {}
for edge in g.edges:
    edge_bool_vars[edge[0], edge[1]] = shortest_path_model.NewBoolVar('edge_%s_%s' % edge)
    print('Creating the boolean variable ', edge_bool_vars[edge[0], edge[1]], 
          'representing the if we should travel through ', (edge[0], edge[1]))
Creating the boolean variable  edge_s_u representing the if we should travel through  ('s', 'u')
Creating the boolean variable  edge_s_v representing the if we should travel through  ('s', 'v')
Creating the boolean variable  edge_u_v representing the if we should travel through  ('u', 'v')
Creating the boolean variable  edge_u_t representing the if we should travel through  ('u', 't')
Creating the boolean variable  edge_v_t representing the if we should travel through  ('v', 't')

The shortest path (in isolation) will have the following properties:
1. Starting node has a degree -1
2. Ending node has a degree +1
3. All intermediatory nodes have degree 0

This can be written in the form of flow balance constraints as follows:

input_node = 's'
output_node = 't'
# Adding constraints on the nodes
for node in g.nodes:
    in_edges = g.in_edges(node)
    out_edges = g.out_edges(node)
    print('Adding the constraint on node ', node)
    print('This node has %i in-edges and %i out-edges' % (len(in_edges), len(out_edges)))
    equation_at_this_edge = sum(edge_bool_vars[edge[0], edge[1]] for edge in in_edges) - \
                            sum(edge_bool_vars[edge[0], edge[1]] for edge in out_edges)
    if(node == input_node):              
        shortest_path_model.Add(equation_at_this_edge == -1)
        print(equation_at_this_edge == -1)
    elif(node == output_node):              
        shortest_path_model.Add(equation_at_this_edge == 1)
        print(equation_at_this_edge == 1)
    else:
        shortest_path_model.Add(equation_at_this_edge == 0)
        print(equation_at_this_edge, '== 0')
    print('')
Adding the constraint on node  s
This node has 0 in-edges and 2 out-edges
(-((edge_s_u) + edge_s_v)) == -1

Adding the constraint on node  u
This node has 1 in-edges and 2 out-edges
((edge_s_u) + -((edge_u_v) + edge_u_t)) == 0

Adding the constraint on node  v
This node has 2 in-edges and 1 out-edges
(((edge_s_v) + edge_u_v) + -(edge_v_t)) == 0

Adding the constraint on node  t
This node has 2 in-edges and 0 out-edges
(((edge_u_t) + edge_v_t)) == 1

The objective of the shortest path problem is to find the path with the minimum cost. This can be written as minimising the costs as follows:

# factor to make everything including costs integer
factor_to_int = 10

# The objective is to maximise flow 
total_cost = sum(int(g.get_edge_data(*edge)['weight']*factor_to_int)*edge_bool_vars[edge[0], edge[1]]
                for edge in g.edges)

print('Objective is to optimise cost')
print(total_cost)
shortest_path_model.Minimize(total_cost)
Objective is to optimise cost
((((((30 * edge_s_u)) + (20 * edge_s_v)) + (7 * edge_u_v)) + (10 * edge_u_t)) + (70 * edge_v_t))

Solving the problem, we have an optimal solution with the overall cost as 40 units.

# Solving the problem
solver = cp_model.CpSolver()
solution_printer = cp_model.ObjectiveSolutionPrinter()
status = solver.SolveWithSolutionCallback(shortest_path_model, solution_printer)
Solution 0, time = 0.02 s, objective = 40
cp_model.OPTIMAL == status
True

The solution is given as

result_edges = {}
for edge in g.edges:
    result_edges[edge[0], edge[1]] = solver.Value(edge_bool_vars[edge[0], edge[1]])
result_edges
{('s', 'u'): 1, ('s', 'v'): 0, ('u', 'v'): 0, ('u', 't'): 1, ('v', 't'): 0}

Plotting the network in such a way that the green lines represent the shortest path, we get

pos = nx.get_node_attributes(g,'pos')
color = ['g' if val==1 else 'r' for val in result_edges.values()]

nx.draw(g,pos, with_labels=True, edge_color= color)

nx.draw_networkx_edge_labels(g,pos,edge_labels = result_edges)
plt.show()

png

Back to top