Dijkstra's Single-Source Shortest Path

Overview

The single-source shortest path (SSSP) problem involves finding the shortest paths from a given source node to all other reachable nodes in a graph. In weighted graphs, the shortest path minimizes the total edge weights; in unweighted graphs, it minimizes the number of edges (hops). The cost or distance of a path refers to this total weight or count.

The concept was introduced by Dutch computer scientist Edsger W. Dijkstra in 1956, originally to determine the shortest path between two nodes. The single-source shortest path is a common variant, facilitating efficient path planning and network analysis.

Concepts

Dijkstra's Single-Source Shortest Path

Below is the basic implementation of the Dijkstra's Single-Source Shortest Path algorithm, along with an example to compute the weighted shortest paths in an undirected graph starting from the source node b:

1. Create a priority queue to store nodes and their corresponding distances from the source node. Initialize the distance of the source node as 0 and the distances of all other nodes as infinity. All nodes are marked as unvisited.

2. Extract the node with the minimum distance from the queue, mark it as visited, and relax each of its unvisited neighbors.

Visit node b:
dist(a) = min(0+2,∞) = 2, dist(c) = min(0+1,∞) = 1

NOTE

The term relaxation refers to the process of updating the distance of a node v that is connected to node u to a potential shorter distance by considering the path through node u. Specifically, the distance of node v is updated to dist(v) = dist(u) + w(u,v), where w(u,v) is the weight of the edge (u,v). This update is performed only if the current dist(v) is greater than dist(u) + w(u,v).

NOTE

Once a node is marked as visited, its shortest path is fixed, and its distance will no longer change throughout the remainder of the algorithm. The algorithm only updates the distances of nodes that have not yet been visited.

3. Repeat step 2 until all nodes are visited.

Visit node c:
dist(d) = min(1+3, ∞) = 4, dist(e) = min(1+4, ∞) = 5, dist(g) = min(1+2, ∞) = 3
Visit node a:
dist(d) = min(2+4, 4) = 4
Visit node g:
dist(f) = min(3+5, ∞) = 8
Visit node d:
No neighbor can be relaxed
Visit node e:
dist(f) = min(5+8, 8) = 8
Visit node f:
No neighbor can be relaxed
The algorithm ends here as all nodes are visited

Considerations

• The Dijkstra's algorithm applies only to graphs with non-negative edge weights. If negative weights exist, Dijkstra's algorithm may yield incorrect results. In this case, a different algorithm like the SPFA should be used instead.
• If multiple shortest paths exist between two nodes, the algorithm will find all of them.
• In disconnected graphs, the algorithm only outputs the shortest paths from the source node to nodes within the same connected component.

Example Graph

Run the following statements on an empty graph to define its structure and insert data:

GQLUQL
ALTER EDGE default ADD PROPERTY {
  value int32
};
INSERT (A:default {_id: "A"}),
       (B:default {_id: "B"}),
       (C:default {_id: "C"}),
       (D:default {_id: "D"}),
       (E:default {_id: "E"}),
       (F:default {_id: "F"}),
       (G:default {_id: "G"}),
       (A)-[:default {value: 2}]->(B),
       (A)-[:default {value: 4}]->(F),
       (B)-[:default {value: 3}]->(C),
       (B)-[:default {value: 3}]->(D),
       (B)-[:default {value: 6}]->(F),
       (D)-[:default {value: 2}]->(E),
       (D)-[:default {value: 2}]->(F),
       (E)-[:default {value: 3}]->(G),
       (F)-[:default {value: 1}]->(E);

Creating HDC Graph

To load the entire graph to the HDC server hdc-server-1 as my_hdc_graph:

GQLUQL
CREATE HDC GRAPH my_hdc_graph ON "hdc-server-1" OPTIONS {
  nodes: {"*": ["*"]},
  edges: {"*": ["*"]},
  direction: "undirected",
  load_id: true,
  update: "static"
}

Parameters

Algorithm name: sssp

File Writeback

GQLUQL
CALL algo.sssp.write("my_hdc_graph", {
  ids: "A",
  edge_schema_property: "@default.value",
  impl_type: "dijkstra",
  return_id_uuid: "id"
}, {
  file: {
    filename: "costs"
  }
})

Result:

File: costs
_id,totalCost
D,5
F,4
B,2
E,5
C,5
G,8

GQLUQL
CALL algo.sssp.write("my_hdc_graph", {
  ids: "A",
  edge_schema_property: "@default.value",
  impl_type: "dijkstra",
  record_path: 1,
  return_id_uuid: "id"
}, {
  file: {
    filename: "paths"
  }
})

Result:

File: costs
totalCost,_ids
8,A--[102]--F--[107]--E--[109]--G
5,A--[101]--B--[105]--D
5,A--[102]--F--[107]--E
5,A--[101]--B--[104]--C
4,A--[102]--F
2,A--[101]--B

Full Return

GQLUQL
CALL algo.sssp.run("my_hdc_graph", {
  ids: 'A',
  edge_schema_property: 'value',
  impl_type: 'dijkstra',
  record_path: 0,
  return_id_uuid: 'id',
  order: 'desc'
}) YIELD r
RETURN r

Result:

Stream Return

GQLUQL
CALL algo.sssp.stream("my_hdc_graph", {
  ids: 'A',
  edge_schema_property: '@default.value',
  impl_type: 'dijkstra',
  record_path: 1,
  return_id_uuid: 'id'
}) YIELD r
RETURN r

Result: