implementation of depth

Author: matiii

src/Dijkstra.NET.Tests/Extensions/ShortestPathExtensionsTests.cs

@@ -155,5 +155,31 @@ public void DijkstraGraphNot_Should_Find_Path_In_Graph()
 
             Assert.False(result.IsFounded);
         }
+
+        [Fact]
+        public void Dijkstra_Should_Concern_Depth_In_Graph()
+        {
+            var graph = new Graph<int, string>();
+
+            graph.AddNode(0);
+            graph.AddNode(0);
+            graph.AddNode(0);
+            graph.AddNode(0);
+
+            graph.Connect(0, 1, 1, null);
+            graph.Connect(0, 2, 1, null);
+            graph.Connect(0, 3, 5, null);
+            graph.Connect(2, 3, 2, null);
+
+            var result = graph.Dijkstra(0, 3, 1);
+
+            Assert.True(result.IsFounded);
+            Assert.Equal(5, result.Distance);
+
+            uint[] path = result.GetPath().ToArray();
+
+            Assert.Equal((uint)0, path[0]);
+            Assert.Equal((uint)3, path[1]);
+        }
     }
 }

src/Dijkstra.NET/Contract/IGraph.cs

@@ -1,7 +1,7 @@
-namespace Dijkstra.NET.Contract
-{
-    using System;
+using System;
 
+namespace Dijkstra.NET.Contract
+{
     public interface IGraph<T, TEdgeCustom> where TEdgeCustom : IEquatable<TEdgeCustom>
     {
         INode<T, TEdgeCustom> this[uint node] { get; }

src/Dijkstra.NET/Extensions/ShortestPathExtensions.cs

@@ -16,11 +16,23 @@ public static class ShortestPathExtensions
         /// <param name="to">End node</param>
         /// <returns>Value with path</returns>
         public static ShortestPathResult Dijkstra<T, TEdgeCustom>(this IGraph<T, TEdgeCustom> graph, uint from, uint to)
+            where TEdgeCustom : IEquatable<TEdgeCustom> => Dijkstra(graph, from, to, Int32.MaxValue);
+
+        /// <summary>
+        /// Get path from @from to @to
+        /// </summary>
+        /// <param name="graph">Source graph</param>
+        /// <param name="from">Start node</param>
+        /// <param name="to">End node</param>
+        /// <param name="depth">Depth of path</param>
+        /// <returns>Value with path</returns>
+        public static ShortestPathResult Dijkstra<T, TEdgeCustom>(this IGraph<T, TEdgeCustom> graph, uint from, uint to, int depth)
             where TEdgeCustom : IEquatable<TEdgeCustom>
         {
             var path = new Dictionary<uint, uint>();
-            var distance = new Dictionary<uint, int> {[from] = 0};
-            var q = new SortedSet<uint>(new[] {from}, new NodeComparer(distance));
+            var distance = new Dictionary<uint, int> { [from] = 0 };
+            var d = new Dictionary<uint, int> { [from] = 0 };
+            var q = new SortedSet<uint>(new[] { from }, new NodeComparer(distance));
             var current = new HashSet<uint>();
 
             int Distance(uint key)
@@ -39,6 +51,11 @@ int Distance(uint key)
 
                 current.Remove(u);
 
+                if (depth == d[u])
+                {
+                    continue;
+                }
+
                 graph[u].EachChild((in Edge<T, TEdgeCustom> e) =>
                 {
                     if (Distance(e.Node.Key) > Distance(u) + e.Cost)
@@ -52,6 +69,7 @@ int Distance(uint key)
                         q.Add(e.Node.Key);
                         current.Add(e.Node.Key);
                         path[e.Node.Key] = u;
+                        d[e.Node.Key] = d[u] + 1;
                     }
                 });
             }

src/Dijkstra.NET/Model/Graph.cs

@@ -10,10 +10,16 @@ public class Graph<T, TEdgeCustom>: IGraph<T, TEdgeCustom>, IEnumerable<INode<T,
     {
         private readonly IDictionary<uint, Node<T, TEdgeCustom>> _nodes = new Dictionary<uint, Node<T, TEdgeCustom>>();
 
-        public void AddNode(T item)
+        /// <summary>
+        /// Add node to graph
+        /// </summary>
+        /// <param name="item">Node</param>
+        /// <returns>Key of node</returns>
+        public uint AddNode(T item)
         {
             uint key = (uint) _nodes.Count;
             AddNode(key, item);
+            return key;
         }
 
         protected void AddNode(uint key, T item)
@@ -24,6 +30,14 @@ protected void AddNode(uint key, T item)
             _nodes.Add(key, new Node<T, TEdgeCustom>(key, item));
         }
 
+        /// <summary>
+        /// Connect node from with node to
+        /// </summary>
+        /// <param name="from">First node</param>
+        /// <param name="to">Second node</param>
+        /// <param name="cost">Cost of connection</param>
+        /// <param name="custom">Information saved in edge</param>
+        /// <returns>Returns true if nodes connected</returns>
         public bool Connect(uint from, uint to, int cost, TEdgeCustom custom)
         {
             if (!_nodes.ContainsKey(from) || !_nodes.ContainsKey(to))
@@ -38,6 +52,7 @@ public bool Connect(uint from, uint to, int cost, TEdgeCustom custom)
         }
 
         public IEnumerator<INode<T, TEdgeCustom>> GetEnumerator() => _nodes.Select(x => x.Value).GetEnumerator();
+
         IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
 
         public INode<T, TEdgeCustom> this[uint node] => _nodes[node];