Add Tarjan's strongly connected components algorithm

Algorithms.Tests/Graph/TarjanStronglyConnectedComponentsTests.cs

@@ -0,0 +1,189 @@
+using Algorithms.Graph;
+using NUnit.Framework;
+using FluentAssertions;
+using System.Linq;
+
+namespace Algorithms.Tests.Graph;
+
+public class TarjanStronglyConnectedComponentsTests
+{
+    [Test]
+    public void FindSCCs_SimpleGraph_ReturnsCorrectSCCs()
+    {
+        var tarjan = new TarjanStronglyConnectedComponents(3);
+        tarjan.AddEdge(0, 1);
+        tarjan.AddEdge(1, 2);
+        tarjan.AddEdge(2, 0);
+
+        var sccs = tarjan.FindSCCs();
+
+        sccs.Should().HaveCount(1);
+        sccs[0].Should().BeEquivalentTo(new[] { 0, 1, 2 });
+    }
+
+    [Test]
+    public void FindSCCs_TwoSeparateSCCs_ReturnsBothSCCs()
+    {
+        var tarjan = new TarjanStronglyConnectedComponents(4);
+        tarjan.AddEdge(0, 1);
+        tarjan.AddEdge(1, 0);
+        tarjan.AddEdge(2, 3);
+        tarjan.AddEdge(3, 2);
+
+        var sccs = tarjan.FindSCCs();
+
+        sccs.Should().HaveCount(2);
+    }
+
+    [Test]
+    public void FindSCCs_DisconnectedVertices_EachVertexIsSCC()
+    {
+        var tarjan = new TarjanStronglyConnectedComponents(3);
+
+        var sccs = tarjan.FindSCCs();
+
+        sccs.Should().HaveCount(3);
+        sccs.Should().OnlyContain(scc => scc.Count == 1);
+    }
+
+    [Test]
+    public void FindSCCs_ComplexGraph_ReturnsCorrectSCCs()
+    {
+        var tarjan = new TarjanStronglyConnectedComponents(8);
+        tarjan.AddEdge(0, 1);
+        tarjan.AddEdge(1, 2);
+        tarjan.AddEdge(2, 0);
+        tarjan.AddEdge(2, 3);
+        tarjan.AddEdge(3, 4);
+        tarjan.AddEdge(4, 5);
+        tarjan.AddEdge(5, 3);
+        tarjan.AddEdge(5, 6);
+        tarjan.AddEdge(6, 7);
+        tarjan.AddEdge(7, 6);
+
+        var sccs = tarjan.FindSCCs();
+
+        sccs.Should().HaveCount(3);
+    }
+
+    [Test]
+    public void GetSCCCount_AfterFindingSCCs_ReturnsCorrectCount()
+    {
+        var tarjan = new TarjanStronglyConnectedComponents(5);
+        tarjan.AddEdge(0, 1);
+        tarjan.AddEdge(1, 0);
+        tarjan.AddEdge(2, 3);
+        tarjan.AddEdge(3, 4);
+        tarjan.AddEdge(4, 2);
+
+        tarjan.FindSCCs();
+        var count = tarjan.GetSCCCount();
+
+        count.Should().Be(2);
+    }
+
+    [Test]
+    public void InSameSCC_VerticesInSameSCC_ReturnsTrue()
+    {
+        var tarjan = new TarjanStronglyConnectedComponents(3);
+        tarjan.AddEdge(0, 1);
+        tarjan.AddEdge(1, 2);
+        tarjan.AddEdge(2, 0);
+
+        var result = tarjan.InSameSCC(0, 2);
+
+        result.Should().BeTrue();
+    }
+
+    [Test]
+    public void InSameSCC_VerticesInDifferentSCCs_ReturnsFalse()
+    {
+        var tarjan = new TarjanStronglyConnectedComponents(4);
+        tarjan.AddEdge(0, 1);
+        tarjan.AddEdge(1, 0);
+        tarjan.AddEdge(2, 3);
+
+        var result = tarjan.InSameSCC(0, 2);
+
+        result.Should().BeFalse();
+    }
+
+    [Test]
+    public void GetSCC_ValidVertex_ReturnsSCCContainingVertex()
+    {
+        var tarjan = new TarjanStronglyConnectedComponents(3);
+        tarjan.AddEdge(0, 1);
+        tarjan.AddEdge(1, 2);
+        tarjan.AddEdge(2, 0);
+
+        var scc = tarjan.GetSCC(1);
+
+        scc.Should().NotBeNull();
+        scc.Should().Contain(1);
+        scc.Should().HaveCount(3);
+    }
+
+    [Test]
+    public void BuildCondensationGraph_ComplexGraph_ReturnsDAG()
+    {
+        var tarjan = new TarjanStronglyConnectedComponents(6);
+        tarjan.AddEdge(0, 1);
+        tarjan.AddEdge(1, 0);
+        tarjan.AddEdge(1, 2);
+        tarjan.AddEdge(2, 3);
+        tarjan.AddEdge(3, 4);
+        tarjan.AddEdge(4, 5);
+        tarjan.AddEdge(5, 3);
+
+        var condensation = tarjan.BuildCondensationGraph();
+
+        condensation.Should().NotBeNull();
+        condensation.Length.Should().Be(2);
+    }
+
+    [Test]
+    public void AddEdge_InvalidVertex_ThrowsException()
+    {
+        var tarjan = new TarjanStronglyConnectedComponents(3);
+
+        var act = () => tarjan.AddEdge(0, 5);
+
+        act.Should().Throw<ArgumentOutOfRangeException>();
+    }
+
+    [Test]
+    public void FindSCCs_SingleVertex_ReturnsSingleSCC()
+    {
+        var tarjan = new TarjanStronglyConnectedComponents(1);
+
+        var sccs = tarjan.FindSCCs();
+
+        sccs.Should().HaveCount(1);
+        sccs[0].Should().BeEquivalentTo(new[] { 0 });
+    }
+
+    [Test]
+    public void FindSCCs_LinearChain_EachVertexIsSCC()
+    {
+        var tarjan = new TarjanStronglyConnectedComponents(4);
+        tarjan.AddEdge(0, 1);
+        tarjan.AddEdge(1, 2);
+        tarjan.AddEdge(2, 3);
+
+        var sccs = tarjan.FindSCCs();
+
+        sccs.Should().HaveCount(4);
+    }
+
+    [Test]
+    public void FindSCCs_SelfLoop_VertexIsSCC()
+    {
+        var tarjan = new TarjanStronglyConnectedComponents(2);
+        tarjan.AddEdge(0, 0);
+        tarjan.AddEdge(0, 1);
+
+        var sccs = tarjan.FindSCCs();
+
+        sccs.Should().Contain(scc => scc.Contains(0) && scc.Count == 1);
+    }
+}

Algorithms/Graph/TarjanStronglyConnectedComponents.cs

@@ -0,0 +1,156 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Algorithms.Graph;
+
+/// <summary>
+/// Tarjan's algorithm for finding strongly connected components in a directed graph.
+/// Uses depth-first search with a stack to identify SCCs in O(V + E) time.
+/// </summary>
+public class TarjanStronglyConnectedComponents
+{
+    private readonly List<int>[] graph;
+    private readonly int[] ids;
+    private readonly int[] low;
+    private readonly bool[] onStack;
+    private readonly Stack<int> stack;
+    private readonly List<List<int>> sccs;
+    private int id;
+
+    public TarjanStronglyConnectedComponents(int vertices)
+    {
+        graph = new List<int>[vertices];
+        ids = new int[vertices];
+        low = new int[vertices];
+        onStack = new bool[vertices];
+        stack = new Stack<int>();
+        sccs = new List<List<int>>();
+
+        for (int i = 0; i < vertices; i++)
+        {
+            graph[i] = new List<int>();
+            ids[i] = -1;
+        }
+    }
+
+    /// <summary>
+    /// Adds a directed edge from u to v.
+    /// </summary>
+    public void AddEdge(int u, int v)
+    {
+        if (u < 0 || u >= graph.Length || v < 0 || v >= graph.Length)
+            throw new ArgumentOutOfRangeException();
+
+        graph[u].Add(v);
+    }
+
+    /// <summary>
+    /// Finds all strongly connected components.
+    /// </summary>
+    /// <returns>List of SCCs, where each SCC is a list of vertex indices.</returns>
+    public List<List<int>> FindSCCs()
+    {
+        for (int i = 0; i < graph.Length; i++)
+        {
+            if (ids[i] == -1)
+                Dfs(i);
+        }
+
+        return sccs;
+    }
+
+    /// <summary>
+    /// Gets the number of strongly connected components.
+    /// </summary>
+    public int GetSCCCount() => sccs.Count;
+
+    /// <summary>
+    /// Checks if two vertices are in the same SCC.
+    /// </summary>
+    public bool InSameSCC(int u, int v)
+    {
+        if (sccs.Count == 0) FindSCCs();
+
+        foreach (var scc in sccs)
+        {
+            if (scc.Contains(u) && scc.Contains(v))
+                return true;
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    /// Gets the SCC containing the given vertex.
+    /// </summary>
+    public List<int>? GetSCC(int vertex)
+    {
+        if (sccs.Count == 0) FindSCCs();
+
+        return sccs.FirstOrDefault(scc => scc.Contains(vertex));
+    }
+
+    /// <summary>
+    /// Builds the condensation graph (DAG of SCCs).
+    /// </summary>
+    public List<int>[] BuildCondensationGraph()
+    {
+        if (sccs.Count == 0) FindSCCs();
+
+        var sccIndex = new int[graph.Length];
+        for (int i = 0; i < sccs.Count; i++)
+        {
+            foreach (var vertex in sccs[i])
+                sccIndex[vertex] = i;
+        }
+
+        var condensation = new List<int>[sccs.Count];
+        for (int i = 0; i < sccs.Count; i++)
+            condensation[i] = new List<int>();
+
+        var edges = new HashSet<(int, int)>();
+        for (int u = 0; u < graph.Length; u++)
+        {
+            foreach (var v in graph[u])
+            {
+                int sccU = sccIndex[u];
+                int sccV = sccIndex[v];
+
+                if (sccU != sccV && !edges.Contains((sccU, sccV)))
+                {
+                    condensation[sccU].Add(sccV);
+                    edges.Add((sccU, sccV));
+                }
+            }
+        }
+
+        return condensation;
+    }
+
+    private void Dfs(int at)
+    {
+        stack.Push(at);
+        onStack[at] = true;
+        ids[at] = low[at] = id++;
+
+        foreach (var to in graph[at])
+        {
+            if (ids[to] == -1) Dfs(to);
+            if (onStack[to]) low[at] = Math.Min(low[at], low[to]);
+        }
+
+        if (ids[at] == low[at])
+        {
+            var scc = new List<int>();
+            while (true)
+            {
+                int node = stack.Pop();
+                onStack[node] = false;
+                scc.Add(node);
+                if (node == at) break;
+            }
+            sccs.Add(scc);
+        }
+    }
+}