Add strongly connected components graph algorithm

Author: appgurueu

.spec/data_structures/graph_spec.lua

@@ -126,6 +126,17 @@ describe("Graph", function()
 		local g = graph.new({ a = { b = 42 }, b = {} })
 		assert.same(g, g:copy())
 	end)
+	it("transposed", function()
+		local g = graph.new({ a = { b = 42 }, b = {}, c = { a = 1, b = 2 } })
+		assert.same(
+			graph.new({
+				a = { c = 1 },
+				b = { a = 42, c = 2 },
+				c = {},
+			}),
+			g:transposed()
+		)
+	end)
 	local function traversal_common(fname)
 		local function visits_all_nodes(g)
 			local expected_nodes = {}
@@ -216,6 +227,37 @@ describe("Graph", function()
 			end
 		end)
 	end)
+	describe("strongly connected components", function()
+		it("works on a simple example", function()
+			local g = graph.new({
+				[1] = { [2] = true },
+				[2] = { [1] = true, [3] = true },
+				[3] = { [4] = true },
+				[4] = { [3] = true },
+			})
+			assert.same({
+				{ [1] = true, [2] = true },
+				{ [3] = true, [4] = true },
+			}, g:strongly_connected_components())
+		end)
+		it("sorts result topologically", function()
+			for _ = 1, 10 do
+				local g = random_directed_acyclic_graph()
+				local rank = {}
+				local i = 0
+				for _, component in ipairs(g:strongly_connected_components()) do
+					local node = assert(next(component))
+					assert.same({ [node] = true }, component)
+					assert.equal(nil, next(component, node))
+					i = i + 1
+					rank[node] = i
+				end
+				for from, to in g:edges() do
+					assert(rank[from] < rank[to])
+				end
+			end
+		end)
+	end)
 	local function test_sssp_limited(name, negative_weights)
 		it("selected graph", negative_weights and function()
 			-- This is an example where the invariant of Dijkstra's algorithm would be broken

src/data_structures/graph.lua

@@ -109,6 +109,18 @@ function graph:edges()
 	end)
 end
 
+--> graph with reversed edge direction
+function graph:transposed()
+	local transposed = graph.new()
+	for node in self:nodes() do
+		transposed:add_node(node)
+	end
+	for from, to, weight in self:edges() do
+		transposed:set_weight(to, from, weight)
+	end
+	return transposed
+end
+
 -- Breadth-first traversal. Can be used to solve shortest path problems if all edges have the same weight.
 function graph:nodes_breadth_first(
 	root -- optional root node to start the traversal from
@@ -248,6 +260,51 @@ function graph:nodes_topological_order()
 	end
 end
 
+-- Kosaraju's algorithm
+--> list of strongly connected components (sets of nodes), topologically sorted
+function graph:strongly_connected_components()
+	local nodes_depth_first = {}
+	do -- "postorder", depth-first traversal
+		local seen = {}
+		local function visit(node)
+			if seen[node] then
+				return
+			end
+			seen[node] = true
+			for neighbor in self:neighbors(node) do
+				visit(neighbor)
+			end
+			table.insert(nodes_depth_first, node)
+		end
+		for node in self:nodes() do
+			visit(node)
+		end
+	end
+	local transposed = self:transposed()
+	local seen = {}
+	local connected_components = {}
+	for i = #nodes_depth_first, 1, -1 do
+		local root = nodes_depth_first[i]
+		if not seen[root] then
+			seen[root] = true
+			local component = {}
+			local to_visit = { root }
+			repeat
+				local node = table.remove(to_visit)
+				component[node] = true
+				for neighbor in transposed:neighbors(node) do
+					if not seen[neighbor] then
+						seen[neighbor] = true
+						table.insert(to_visit, neighbor)
+					end
+				end
+			until to_visit[1] == nil
+			table.insert(connected_components, component)
+		end
+	end
+	return connected_components
+end
+
 -- Single source shortest paths using Dijkstra.
 -- Requires positive weights.
 function graph:sssp_dijkstra(source)