5.5.3. Single Source Shortest Path

This section describes the Single Source Shortest Path algorithm in the Neo4j Graph Data Science library.

The Single Source Shortest Path (SSSP) algorithm calculates the shortest (weighted) path from a node to all other nodes in the graph.

This algorithm is in the alpha tier. For more information on this tier of algorithm, see here.

This section includes:

History and explanation
Use-cases - when to use the Single Source Shortest Path algorithm
Constraints - when not to use the Single Source Shortest Path algorithm
Syntax
Single Source Shortest Path algorithm sample
- Delta stepping algorithm
  - Cypher projection

5.5.3.1. History and explanation

SSSP came into prominence at the same time as the shortest path algorithm and Dijkstra’s algorithm can act as an implementation for both problems.

We implement a delta-stepping algorithm that has been shown to outperform Dijkstra’s.

5.5.3.2. Use-cases - when to use the Single Source Shortest Path algorithm

Open Shortest Path First is a routing protocol for IP networks. It uses Dijkstra’s algorithm to help detect changes in topology, such as link failures, and come up with a new routing structure in seconds.

5.5.3.3. Constraints - when not to use the Single Source Shortest Path algorithm

Delta stepping does not support negative weights. The algorithm assumes that adding a relationship to a path can never make a path shorter - an invariant that would be violated with negative weights.

5.5.3.4. Syntax

The following will run the algorithm and write back results:

CALL gds.alpha.shortestPath.deltaStepping.write(configuration: Map)
YIELD nodeCount, loadDuration, evalDuration, writeDuration

Table 5.346. Configuration
Name	Type	Default	Optional	Description
startNode	Node	null	no	The start node
relationshipWeightProperty	String	null	yes	The property name that contains weight. If null, treats the graph as unweighted. Must be numeric.
delta	Float	null	yes	The grade of concurrency to use.
writeProperty	String	'sssp'	yes	The property name written back to the node sequence of the node in the path. The property contains the cost it takes to get from the start node to the specific node.

Table 5.347. Results
Name	Type	Description
nodeCount	Integer	The number of nodes considered
loadDuration	Integer	Milliseconds for loading data
evalDuration	Integer	Milliseconds for running the algorithm
writeDuration	Integer	Milliseconds for writing result data back

The following will run the algorithm and stream results:

CALL gds.shortestPath.deltaStepping.stream(configuration: Map)
YIELD nodeId, distance

Table 5.348. Parameters
Name	Type	Default	Optional	Description
startNode	Node	null	no	The start node
relationshipWeightProperty	String	null	yes	The property name that contains weight. If null, treats the graph as unweighted. Must be numeric.
delta	Float	null	yes	The grade of concurrency to use.

Table 5.349. Results
Name	Type	Description
nodeId	Integer	Node ID
distance	Integer	The cost it takes to get from the start node to the specific node.

5.5.3.5. Single Source Shortest Path algorithm sample

The following will create a sample graph:

CREATE (a:Loc {name: 'A'}),
       (b:Loc {name: 'B'}),
       (c:Loc {name: 'C'}),
       (d:Loc {name: 'D'}),
       (e:Loc {name: 'E'}),
       (f:Loc {name: 'F'}),
       (a)-[:ROAD {cost: 50}]->(b),
       (a)-[:ROAD {cost: 50}]->(c),
       (a)-[:ROAD {cost: 100}]->(d),
       (b)-[:ROAD {cost: 40}]->(d),
       (c)-[:ROAD {cost: 40}]->(d),
       (c)-[:ROAD {cost: 80}]->(e),
       (d)-[:ROAD {cost: 30}]->(e),
       (d)-[:ROAD {cost: 80}]->(f),
       (e)-[:ROAD {cost: 40}]->(f);

Delta stepping algorithm

The following will run the algorithm and stream results:

MATCH (n:Loc {name: 'A'})
CALL gds.alpha.shortestPath.deltaStepping.stream({
  nodeProjection: 'Loc',
  relationshipProjection: {
    ROAD: {
      type: 'ROAD',
      properties: 'cost'
    }
  },
  startNode: n,
  relationshipWeightProperty: 'cost',
  delta: 3.0
})
YIELD nodeId, distance
RETURN gds.util.asNode(nodeId).name AS destination, distance

Table 5.350. Results
Name	Cost
A	0
B	50
C	50
D	90
E	120
F	160

The above table shows the cost of going from A to each of the other nodes, including itself at a cost of 0.

The following will run the algorithm and write back results:

MATCH (n:Loc {name: 'A'})
CALL gds.alpha.shortestPath.deltaStepping.write({
  nodeProjection: 'Loc',
  relationshipProjection: {
    ROAD: {
      type: 'ROAD',
      properties: 'cost'
    }
  },
  startNode: n,
  relationshipWeightProperty: 'cost',
  delta: 3.0,
  writeProperty: 'sssp'
})
YIELD nodeCount, loadDuration, evalDuration, writeDuration
RETURN nodeCount, loadDuration, evalDuration, writeDuration

Table 5.351. Results
nodeCount
6

Cypher projection

If node label and relationship type are not selective enough to create the graph projection to run the algorithm on, you can use Cypher queries to project your graph. This can also be used to run algorithms on a virtual graph. You can learn more in the Section 4.3, “Cypher projection” section of the manual.

MATCH (start:Loc {name: 'A'})
CALL gds.alpha.shortestPath.deltaStepping.write({
  nodeQuery:'MATCH(n:Loc) WHERE not n.name = "c" RETURN id(n) AS id',
  relationshipQuery:'MATCH(n:Loc)-[r:ROAD]->(m:Loc) RETURN id(n) AS source, id(m) AS target, r.cost AS weight',
  startNode: start,
  relationshipWeightProperty: 'weight',
  delta: 3.0,
  writeProperty: 'sssp'
})
YIELD nodeCount
RETURN nodeCount