directed weighted multigraph SSSP

Graph/DirectedWeightedMultiGraph.cs

@@ -34,7 +34,13 @@ namespace MoonTools.Core.Graph
         public IEnumerable<int> Weights(TNode v, TNode u)
         {
             CheckNodes(v, u);
-            return edges[(v, u)].Select(id => weights[id]);
+            return edges[(v, u)].Select(id => Weight(id));
+        }
+
+        public int Weight(Guid id)
+        {
+            if (!IDToEdge.ContainsKey(id)) { throw new ArgumentException($"Edge with id {id} does not exist in the graph"); }
+            return weights[id];
         }
 
         private IEnumerable<Guid> ReconstructPath(PooledDictionary<TNode, Guid> cameFrom, TNode currentNode)
@@ -115,5 +121,149 @@ namespace MoonTools.Core.Graph
 
             yield break;
         }
+
+        private IEnumerable<Guid> ShortestPath(TNode start, TNode end, Func<TNode, IEnumerable<(TNode, Guid, int)>> SSSPAlgorithm)
+        {
+            CheckNodes(start, end);
+
+            var cameFrom = new PooledDictionary<TNode, Guid>(ClearMode.Always);
+            var reachable = new PooledSet<TNode>(ClearMode.Always);
+
+            foreach (var (node, previous, weight) in SSSPAlgorithm(start))
+            {
+                cameFrom[node] = previous;
+                reachable.Add(node);
+            }
+
+            if (!reachable.Contains(end))
+            {
+                cameFrom.Dispose();
+                reachable.Dispose();
+                yield break;
+            }
+
+            foreach (var edge in ReconstructPath(cameFrom, end).Reverse())
+            {
+                yield return edge;
+            }
+
+            cameFrom.Dispose();
+            reachable.Dispose();
+        }
+
+        public IEnumerable<(TNode, Guid, int)> DijkstraSingleSourceShortestPath(TNode source)
+        {
+            if (weights.Values.Any(w => w < 0)) { throw new NegativeWeightException("Dijkstra cannot be used on a graph with negative edge weights. Try Bellman-Ford"); }
+            CheckNodes(source);
+
+            var distance = new PooledDictionary<TNode, int>(ClearMode.Always);
+            var previousEdgeIDs = new PooledDictionary<TNode, Guid>(ClearMode.Always);
+
+            foreach (var node in Nodes)
+            {
+                distance[node] = int.MaxValue;
+            }
+
+            distance[source] = 0;
+
+            var q = Nodes.ToPooledList();
+
+            while (q.Count > 0)
+            {
+                var node = q.MinBy(n => distance[n]).First();
+                q.Remove(node);
+                if (distance[node] == int.MaxValue) { break; }
+
+                foreach (var neighbor in Neighbors(node))
+                {
+                    foreach (var edgeID in EdgeIDs(node, neighbor))
+                    {
+                        var weight = Weight(edgeID);
+
+                        var alt = distance[node] + weight;
+                        if (alt < distance[neighbor])
+                        {
+                            distance[neighbor] = alt;
+                            previousEdgeIDs[neighbor] = edgeID;
+                        }
+                    }
+                }
+            }
+
+            foreach (var node in Nodes)
+            {
+                if (previousEdgeIDs.ContainsKey(node) && distance.ContainsKey(node))
+                {
+                    yield return (node, previousEdgeIDs[node], distance[node]);
+                }
+            }
+
+            distance.Dispose();
+            previousEdgeIDs.Dispose();
+        }
+
+        public IEnumerable<Guid> DijkstraShortestPath(TNode start, TNode end)
+        {
+            return ShortestPath(start, end, DijkstraSingleSourceShortestPath);
+        }
+
+        public IEnumerable<(TNode, Guid, int)> BellmanFordSingleSourceShortestPath(TNode source)
+        {
+            CheckNodes(source);
+
+            var distance = new PooledDictionary<TNode, int>(ClearMode.Always);
+            var previous = new PooledDictionary<TNode, Guid>(ClearMode.Always);
+
+            foreach (var node in Nodes)
+            {
+                distance[node] = int.MaxValue;
+            }
+
+            distance[source] = 0;
+
+            for (int i = 0; i < Order; i++)
+            {
+                foreach (var edgeID in IDToEdge.Keys)
+                {
+                    var weight = Weight(edgeID);
+                    var (v, u) = IDToEdge[edgeID];
+
+                    if (distance[v] + weight < distance[u])
+                    {
+                        distance[u] = distance[v] + weight;
+                        previous[u] = edgeID;
+                    }
+                }
+            }
+
+            foreach (var edgeID in IDToEdge.Keys)
+            {
+                var (v, u) = IDToEdge[edgeID];
+
+                foreach (var weight in Weights(v, u))
+                {
+                    if (distance[v] + weight < distance[u])
+                    {
+                        throw new NegativeCycleException();
+                    }
+                }
+            }
+
+            foreach (var node in Nodes)
+            {
+                if (previous.ContainsKey(node) && distance.ContainsKey(node))
+                {
+                    yield return (node, previous[node], distance[node]);
+                }
+            }
+
+            distance.Dispose();
+            previous.Dispose();
+        }
+
+        public IEnumerable<Guid> BellmanFordShortestPath(TNode start, TNode end)
+        {
+            return ShortestPath(start, end, BellmanFordSingleSourceShortestPath);
+        }
     }
 }

Graph/MultiGraph.cs

@@ -47,13 +47,25 @@ namespace MoonTools.Core.Graph
             return edges.ContainsKey((v, u));
         }
 
-        public TEdgeData EdgeData(Guid id)
+        private void CheckID(Guid id)
         {
-            if (!edgeToEdgeData.ContainsKey(id))
+            if (!Exists(id)) { throw new ArgumentException($"Edge {id} does not exist in the graph."); }
-            {
-                throw new ArgumentException($"Edge {id} does not exist in the graph.");
         }
 
+        public bool Exists(Guid id)
+        {
+            return IDToEdge.ContainsKey(id);
+        }
+
+        public (TNode, TNode) EdgeNodes(Guid id)
+        {
+            CheckID(id);
+            return IDToEdge[id];
+        }
+
+        public TEdgeData EdgeData(Guid id)
+        {
+            CheckID(id);
             return edgeToEdgeData[id];
         }
     }

README.md

@@ -4,7 +4,7 @@ A GC-friendly graph theory library for C# intended for use with games.
 
 ## Usage
 
-`Graph` implements the following graph structures:
+`Graph` implements various algorithms on the following graph structures:
 
 * Directed
 * Directed Weighted

test/DirectedWeightedMultiGraph.cs

@@ -252,5 +252,241 @@ namespace Tests
             // have to call Count() because otherwise the lazy evaluation wont trigger
             myGraph.Invoking(x => x.AStarShortestPath('a', 'z', (x, y) => 1).Count()).Should().Throw<System.ArgumentException>();
         }
+
+        [Test]
+        public void DijsktraSingleSourceShortestPath()
+        {
+            var run = new MoveTypeEdgeData { moveType = MoveType.Run };
+            var jump = new MoveTypeEdgeData { moveType = MoveType.Jump };
+            var wallJump = new MoveTypeEdgeData { moveType = MoveType.WallJump };
+
+            var myGraph = new DirectedWeightedMultiGraph<char, MoveTypeEdgeData>();
+            myGraph.AddNodes('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h');
+
+            var edgeA = myGraph.AddEdge('a', 'b', 2, run);
+            var edgeB = myGraph.AddEdge('a', 'c', 1, jump);
+            var edgeC = myGraph.AddEdge('b', 'd', 2, jump);
+            var edgeD = myGraph.AddEdge('b', 'e', 1, run);
+            var edgeE = myGraph.AddEdge('d', 'f', 2, run);
+            var edgeF = myGraph.AddEdge('c', 'g', 2, run);
+            var edgeG = myGraph.AddEdge('d', 'h', 3, wallJump);
+
+            myGraph.AddEdges(
+                ('a', 'c', 3, run),
+                ('a', 'e', 4, wallJump),
+                ('b', 'd', 5, run),
+                ('c', 'g', 4, jump),
+                ('c', 'h', 11, run),
+                ('d', 'c', 3, jump),
+                ('e', 'f', 5, run),
+                ('f', 'd', 2, run),
+                ('f', 'h', 6, wallJump),
+                ('g', 'h', 7, run),
+                ('h', 'f', 1, jump),
+                ('a', 'a', 3, jump) // cheeky lil self-edge
+            );
+
+            myGraph
+                .DijkstraSingleSourceShortestPath('a')
+                .Should()
+                .Contain(('b', edgeA, 2)).And
+                .Contain(('c', edgeB, 1)).And
+                .Contain(('d', edgeC, 4)).And
+                .Contain(('e', edgeD, 3)).And
+                .Contain(('f', edgeE, 6)).And
+                .Contain(('g', edgeF, 3)).And
+                .Contain(('h', edgeG, 7)).And
+                .HaveCount(7);
+
+            // have to call Count() because otherwise the lazy evaluation wont trigger
+            myGraph.Invoking(x => x.DijkstraSingleSourceShortestPath('z').Count()).Should().Throw<System.ArgumentException>();
+        }
+
+        [Test]
+        public void DijkstraShortestPath()
+        {
+            var run = new MoveTypeEdgeData { moveType = MoveType.Run };
+            var jump = new MoveTypeEdgeData { moveType = MoveType.Jump };
+            var wallJump = new MoveTypeEdgeData { moveType = MoveType.WallJump };
+
+            var myGraph = new DirectedWeightedMultiGraph<char, MoveTypeEdgeData>();
+            myGraph.AddNodes('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h');
+
+            var edgeA = myGraph.AddEdge('a', 'b', 2, run);
+            var edgeB = myGraph.AddEdge('a', 'c', 1, jump);
+            var edgeC = myGraph.AddEdge('b', 'd', 2, jump);
+            var edgeD = myGraph.AddEdge('b', 'e', 1, run);
+            var edgeE = myGraph.AddEdge('d', 'f', 2, run);
+            var edgeF = myGraph.AddEdge('c', 'g', 2, run);
+            var edgeG = myGraph.AddEdge('d', 'h', 3, wallJump);
+
+            myGraph.AddEdges(
+                ('a', 'c', 3, run),
+                ('a', 'e', 4, wallJump),
+                ('b', 'd', 5, run),
+                ('c', 'g', 4, jump),
+                ('c', 'h', 11, run),
+                ('d', 'c', 3, jump),
+                ('e', 'f', 5, run),
+                ('f', 'd', 2, run),
+                ('f', 'h', 6, wallJump),
+                ('g', 'h', 7, run),
+                ('h', 'f', 1, jump),
+                ('a', 'a', 3, jump) // cheeky lil self-edge
+            );
+
+            myGraph
+                .DijkstraShortestPath('a', 'h')
+                .Select(edgeID => myGraph.EdgeData(edgeID))
+                .Should()
+                .ContainInOrder(
+                    run, jump, wallJump
+                )
+                .And
+                .HaveCount(3);
+
+            myGraph.Invoking(x => x.DijkstraShortestPath('a', 'z').Count()).Should().Throw<System.ArgumentException>();
+        }
+
+        [Test]
+        public void BellmanFordSingleSourceShortestPath()
+        {
+            var run = new MoveTypeEdgeData { moveType = MoveType.Run };
+            var jump = new MoveTypeEdgeData { moveType = MoveType.Jump };
+            var wallJump = new MoveTypeEdgeData { moveType = MoveType.WallJump };
+
+            var myGraph = new DirectedWeightedMultiGraph<char, MoveTypeEdgeData>();
+            myGraph.AddNodes('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h');
+
+            var edgeA = myGraph.AddEdge('a', 'b', 2, run);
+            var edgeB = myGraph.AddEdge('a', 'c', 1, jump);
+            var edgeC = myGraph.AddEdge('b', 'd', 2, jump);
+            var edgeD = myGraph.AddEdge('b', 'e', 1, run);
+            var edgeE = myGraph.AddEdge('d', 'f', 2, run);
+            var edgeF = myGraph.AddEdge('c', 'g', 2, run);
+            var edgeG = myGraph.AddEdge('d', 'h', 3, wallJump);
+
+            myGraph.AddEdges(
+                ('a', 'c', 3, run),
+                ('a', 'e', 4, wallJump),
+                ('b', 'd', 5, run),
+                ('c', 'g', 4, jump),
+                ('c', 'h', 11, run),
+                ('d', 'c', 3, jump),
+                ('e', 'f', 5, run),
+                ('f', 'd', 2, run),
+                ('f', 'h', 6, wallJump),
+                ('g', 'h', 7, run),
+                ('h', 'f', 1, jump),
+                ('a', 'a', 3, jump) // cheeky lil self-edge
+            );
+
+            myGraph
+                .BellmanFordSingleSourceShortestPath('a')
+                .Should()
+                .Contain(('b', edgeA, 2)).And
+                .Contain(('c', edgeB, 1)).And
+                .Contain(('d', edgeC, 4)).And
+                .Contain(('e', edgeD, 3)).And
+                .Contain(('f', edgeE, 6)).And
+                .Contain(('g', edgeF, 3)).And
+                .Contain(('h', edgeG, 7)).And
+                .HaveCount(7);
+
+            // have to call Count() because otherwise the lazy evaluation wont trigger
+            myGraph.Invoking(x => x.BellmanFordSingleSourceShortestPath('z').Count()).Should().Throw<System.ArgumentException>();
+        }
+
+        [Test]
+        public void BellmanFordSingleSourceShortestPathNegative()
+        {
+            var run = new MoveTypeEdgeData { moveType = MoveType.Run };
+            var jump = new MoveTypeEdgeData { moveType = MoveType.Jump };
+            var wallJump = new MoveTypeEdgeData { moveType = MoveType.WallJump };
+
+            var myGraph = new DirectedWeightedMultiGraph<char, MoveTypeEdgeData>();
+            myGraph.AddNodes('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h');
+
+            var edgeA = myGraph.AddEdge('a', 'b', 2, run);
+            var edgeB = myGraph.AddEdge('a', 'c', 1, jump);
+            var edgeC = myGraph.AddEdge('b', 'd', -1, jump);
+            var edgeD = myGraph.AddEdge('b', 'e', 1, run);
+            var edgeE = myGraph.AddEdge('d', 'f', 2, run);
+            var edgeF = myGraph.AddEdge('c', 'g', 2, run);
+            var edgeG = myGraph.AddEdge('d', 'h', 3, wallJump);
+
+            myGraph.AddEdges(
+                ('a', 'c', 3, run),
+                ('a', 'e', 4, wallJump),
+                ('b', 'd', 5, run),
+                ('c', 'g', 4, jump),
+                ('c', 'h', 11, run),
+                ('d', 'c', 3, jump),
+                ('e', 'f', 5, run),
+                ('f', 'd', 2, run),
+                ('f', 'h', 6, wallJump),
+                ('g', 'h', 7, run),
+                ('h', 'f', 1, jump),
+                ('a', 'a', 3, jump) // cheeky lil self-edge
+            );
+
+            myGraph
+                .BellmanFordSingleSourceShortestPath('a')
+                .Should()
+                .Contain(('b', edgeA, 2)).And
+                .Contain(('c', edgeB, 1)).And
+                .Contain(('d', edgeC, 1)).And
+                .Contain(('e', edgeD, 3)).And
+                .Contain(('f', edgeE, 3)).And
+                .Contain(('g', edgeF, 3)).And
+                .Contain(('h', edgeG, 4)).And
+                .HaveCount(7);
+        }
+
+        [Test]
+        public void BellmanFordShortestPath()
+        {
+            var run = new MoveTypeEdgeData { moveType = MoveType.Run };
+            var jump = new MoveTypeEdgeData { moveType = MoveType.Jump };
+            var wallJump = new MoveTypeEdgeData { moveType = MoveType.WallJump };
+
+            var myGraph = new DirectedWeightedMultiGraph<char, MoveTypeEdgeData>();
+            myGraph.AddNodes('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h');
+
+            var edgeA = myGraph.AddEdge('a', 'b', 2, run);
+            var edgeB = myGraph.AddEdge('a', 'c', 1, jump);
+            var edgeC = myGraph.AddEdge('b', 'd', 2, jump);
+            var edgeD = myGraph.AddEdge('b', 'e', 1, run);
+            var edgeE = myGraph.AddEdge('d', 'f', 2, run);
+            var edgeF = myGraph.AddEdge('c', 'g', 2, run);
+            var edgeG = myGraph.AddEdge('d', 'h', 3, wallJump);
+
+            myGraph.AddEdges(
+                ('a', 'c', 3, run),
+                ('a', 'e', 4, wallJump),
+                ('b', 'd', 5, run),
+                ('c', 'g', 4, jump),
+                ('c', 'h', 11, run),
+                ('d', 'c', 3, jump),
+                ('e', 'f', 5, run),
+                ('f', 'd', 2, run),
+                ('f', 'h', 6, wallJump),
+                ('g', 'h', 7, run),
+                ('h', 'f', 1, jump),
+                ('a', 'a', 3, jump) // cheeky lil self-edge
+            );
+
+            myGraph
+                .BellmanFordShortestPath('a', 'h')
+                .Select(edgeID => myGraph.EdgeData(edgeID))
+                .Should()
+                .ContainInOrder(
+                    run, jump, wallJump
+                )
+                .And
+                .HaveCount(3);
+
+            myGraph.Invoking(x => x.BellmanFordShortestPath('a', 'z').Count()).Should().Throw<System.ArgumentException>();
+        }
     }
 }