justcoding121
diff --git a/‎src/Advanced.Algorithms/DataStructures/Graph/AdjacencyList/DiGraph.cs‎
Lines changed: 13 additions & 12 deletions b/‎src/Advanced.Algorithms/DataStructures/Graph/AdjacencyList/DiGraph.cs‎
Lines changed: 13 additions & 12 deletions
diff --git a/‎src/Advanced.Algorithms/DataStructures/Graph/AdjacencyList/Graph.cs‎
Lines changed: 6 additions & 5 deletions b/‎src/Advanced.Algorithms/DataStructures/Graph/AdjacencyList/Graph.cs‎
Lines changed: 6 additions & 5 deletions
diff --git a/‎src/Advanced.Algorithms/DataStructures/Graph/AdjacencyList/WeightedDiGraph.cs‎
Lines changed: 7 additions & 6 deletions b/‎src/Advanced.Algorithms/DataStructures/Graph/AdjacencyList/WeightedDiGraph.cs‎
Lines changed: 7 additions & 6 deletions
diff --git a/‎src/Advanced.Algorithms/DataStructures/Graph/AdjacencyList/WeightedGraph.cs‎
Lines changed: 2 additions & 1 deletion b/‎src/Advanced.Algorithms/DataStructures/Graph/AdjacencyList/WeightedGraph.cs‎
Lines changed: 2 additions & 1 deletion
diff --git a/‎src/Advanced.Algorithms/DataStructures/Graph/IDiGraph.cs‎
Lines changed: 10 additions & 15 deletions b/‎src/Advanced.Algorithms/DataStructures/Graph/IDiGraph.cs‎
Lines changed: 10 additions & 15 deletions
diff --git a/‎src/Advanced.Algorithms/DataStructures/Graph/IGraph.cs‎
Lines changed: 10 additions & 9 deletions b/‎src/Advanced.Algorithms/DataStructures/Graph/IGraph.cs‎
Lines changed: 10 additions & 9 deletions
@@ -13,6 +13,7 @@ public class DiGraph<T> : IDiGraph<T>
     {
         public int VerticesCount => Vertices.Count;
         internal Dictionary<T, DiGraphVertex<T>> Vertices { get; set; }
+        public bool IsWeightedGraph => false;
 
         public DiGraph()
         {
@@ -41,8 +42,7 @@ public DiGraphVertex<T> ReferenceVertex
         }
 
         IDiGraphVertex<T> IDiGraph<T>.ReferenceVertex => ReferenceVertex;
-
-
+        
         /// <summary>
         /// Add a new vertex to this graph.
         /// Time complexity: O(1).
@@ -163,7 +163,7 @@ public IEnumerable<T> OutEdges(T vertex)
                 throw new ArgumentException("vertex is not in this graph.");
             }
 
-            return Vertices[vertex].OutEdges.Select(x => x.Value);
+            return Vertices[vertex].OutEdges.Select(x => x.Key);
         }
 
         public IEnumerable<T> InEdges(T vertex)
@@ -173,7 +173,7 @@ public IEnumerable<T> InEdges(T vertex)
                 throw new ArgumentException("vertex is not in this graph.");
             }
 
-            return Vertices[vertex].InEdges.Select(x => x.Value);
+            return Vertices[vertex].InEdges.Select(x => x.Key);
         }
 
         /// <summary>
@@ -201,7 +201,7 @@ public DiGraph<T> Clone()
             {
                 foreach (var edge in vertex.Value.OutEdges)
                 {
-                    newGraph.AddEdge(vertex.Value.Value, edge.Value);
+                    newGraph.AddEdge(vertex.Value.Key, edge.Key);
                 }
             }
 
@@ -218,6 +218,11 @@ public IDiGraphVertex<T> GetVertex(T value)
             return Vertices[value];
         }
 
+        IDiGraph<T> IDiGraph<T>.Clone()
+        {
+            return Clone();
+        }
+
         IEnumerator<IDiGraphVertex<T>> IEnumerable<IDiGraphVertex<T>>.GetEnumerator()
         {
             return GetEnumerator() as IEnumerator<IDiGraphVertex<T>>;
@@ -228,10 +233,6 @@ public IEnumerator GetEnumerator()
             return Vertices.Select(x => x.Value).GetEnumerator();
         }
 
-        IDiGraph<T> IDiGraph<T>.Clone()
-        {
-            throw new NotImplementedException();
-        }
     }
 
     /// <summary>
@@ -240,7 +241,7 @@ IDiGraph<T> IDiGraph<T>.Clone()
     /// </summary>
     public class DiGraphVertex<T> : IDiGraphVertex<T>, IEnumerable<T>
     {
-        public T Value { get; set; }
+        public T Key { get; set; }
 
         public HashSet<DiGraphVertex<T>> OutEdges { get; set; }
         public HashSet<DiGraphVertex<T>> InEdges { get; set; }
@@ -253,7 +254,7 @@ public class DiGraphVertex<T> : IDiGraphVertex<T>, IEnumerable<T>
 
         public DiGraphVertex(T value)
         {
-            Value = value;
+            Key = value;
             OutEdges = new HashSet<DiGraphVertex<T>>();
             InEdges = new HashSet<DiGraphVertex<T>>();
         }
@@ -271,7 +272,7 @@ IEnumerator IEnumerable.GetEnumerator()
 
         public IEnumerator<T> GetEnumerator()
         {
-            return OutEdges.Select(x => x.Value).GetEnumerator();
+            return OutEdges.Select(x => x.Key).GetEnumerator();
         }
 
     }
 
@@ -13,6 +13,7 @@ public class Graph<T> : IGraph<T>
     {
         public int VerticesCount => Vertices.Count;
         internal Dictionary<T, GraphVertex<T>> Vertices { get; set; }
+        public bool IsWeightedGraph => false;
 
         public Graph()
         {
@@ -159,7 +160,7 @@ public IEnumerable<T> Edges(T vertex)
                 throw new ArgumentException("vertex is not in this graph.");
             }
 
-            return Vertices[vertex].Edges.Select(x => x.Value);
+            return Vertices[vertex].Edges.Select(x => x.Key);
         }
 
         /// <summary>
@@ -202,7 +203,7 @@ public Graph<T> Clone()
             {
                 foreach (var edge in vertex.Value.Edges)
                 {
-                    newGraph.AddEdge(vertex.Value.Value, edge.Value);
+                    newGraph.AddEdge(vertex.Value.Key, edge.Key);
                 }
             }
 
@@ -231,15 +232,15 @@ IGraph<T> IGraph<T>.Clone()
     /// </summary>
     public class GraphVertex<T> : IEnumerable<T>, IGraphVertex<T>
     {
-        public T Value { get; set; }
+        public T Key { get; set; }
 
         public HashSet<GraphVertex<T>> Edges { get; set; }
 
         IEnumerable<IEdge<T>> IGraphVertex<T>.Edges => Edges.Select(x => new Edge<T, int>(x, 1));
 
         public GraphVertex(T value)
         {
-            Value = value;
+            Key = value;
             Edges = new HashSet<GraphVertex<T>>();
         }
 
@@ -250,7 +251,7 @@ IEnumerator IEnumerable.GetEnumerator()
 
         public IEnumerator<T> GetEnumerator()
         {
-            return Edges.Select(x => x.Value).GetEnumerator();
+            return Edges.Select(x => x.Key).GetEnumerator();
         }
     }
 }
@@ -13,6 +13,7 @@ public class WeightedDiGraph<T, TW> : IDiGraph<T> where TW : IComparable
     {
         public int VerticesCount => Vertices.Count;
         internal Dictionary<T, WeightedDiGraphVertex<T, TW>> Vertices { get; set; }
+        public bool IsWeightedGraph => true;
 
         public WeightedDiGraph()
         {
@@ -164,7 +165,7 @@ public IEnumerable<Tuple<T, TW>> OutEdges(T vertex)
                 throw new ArgumentException("vertex is not in this graph.");
             }
 
-            return Vertices[vertex].OutEdges.Select(x => new Tuple<T, TW>(x.Key.Value, x.Value));
+            return Vertices[vertex].OutEdges.Select(x => new Tuple<T, TW>(x.Key.Key, x.Value));
         }
 
         public IEnumerable<Tuple<T, TW>> InEdges(T vertex)
@@ -174,7 +175,7 @@ public IEnumerable<Tuple<T, TW>> InEdges(T vertex)
                 throw new ArgumentException("vertex is not in this graph.");
             }
 
-            return Vertices[vertex].InEdges.Select(x => new Tuple<T, TW>(x.Key.Value, x.Value));
+            return Vertices[vertex].InEdges.Select(x => new Tuple<T, TW>(x.Key.Key, x.Value));
         }
 
         /// <summary>
@@ -217,7 +218,7 @@ public WeightedDiGraph<T, TW> Clone()
             {
                 foreach (var edge in vertex.Value.OutEdges)
                 {
-                    newGraph.AddEdge(vertex.Value.Value, edge.Key.Value, edge.Value);
+                    newGraph.AddEdge(vertex.Value.Key, edge.Key.Key, edge.Value);
                 }
             }
 
@@ -246,7 +247,7 @@ IDiGraph<T> IDiGraph<T>.Clone()
     /// </summary>
     public class WeightedDiGraphVertex<T, TW> : IDiGraphVertex<T>, IEnumerable<T> where TW : IComparable
     {
-        public T Value { get; private set; }
+        public T Key { get; private set; }
 
         public Dictionary<WeightedDiGraphVertex<T, TW>, TW> OutEdges { get; set; }
         public Dictionary<WeightedDiGraphVertex<T, TW>, TW> InEdges { get; set; }
@@ -259,7 +260,7 @@ public class WeightedDiGraphVertex<T, TW> : IDiGraphVertex<T>, IEnumerable<T> wh
 
         public WeightedDiGraphVertex(T value)
         {
-            Value = value;
+            Key = value;
 
             OutEdges = new Dictionary<WeightedDiGraphVertex<T, TW>, TW>();
             InEdges = new Dictionary<WeightedDiGraphVertex<T, TW>, TW>();
@@ -278,7 +279,7 @@ IEnumerator IEnumerable.GetEnumerator()
 
         public IEnumerator<T> GetEnumerator()
         {
-            return OutEdges.Select(x => x.Key.Value).GetEnumerator();
+            return OutEdges.Select(x => x.Key.Key).GetEnumerator();
         }
 
 
 
@@ -13,6 +13,7 @@ public class WeightedGraph<T, TW> : IGraph<T> where TW : IComparable
     {
         public int VerticesCount => Vertices.Count;
         internal Dictionary<T, WeightedGraphVertex<T, TW>> Vertices { get; set; }
+        public bool IsWeightedGraph => true;
 
         public WeightedGraph()
         {
@@ -231,7 +232,7 @@ public class WeightedGraphVertex<T, TW> : IGraphVertex<T>, IEnumerable<T> where
         public T Value { get; private set; }
 
         public Dictionary<WeightedGraphVertex<T, TW>, TW> Edges { get; }
-        T IGraphVertex<T>.Value => Value;
+        T IGraphVertex<T>.Key => Value;
 
         IEnumerable<IEdge<T>> IGraphVertex<T>.Edges => Edges.Select(x => new Edge<T, TW>(x.Key, x.Value));
 
 
@@ -1,60 +1,55 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace Advanced.Algorithms.DataStructures.Graph
 {
     public interface IDiGraph<T> : IEnumerable<IDiGraphVertex<T>>
     {
+        bool IsWeightedGraph { get; }
+
         bool ContainsVertex(T value);
-        IDiGraphVertex<T> GetVertex(T value);
+        IDiGraphVertex<T> GetVertex(T key);
         IDiGraphVertex<T> ReferenceVertex { get; }
 
         int VerticesCount { get; }
 
         bool HasEdge(T source, T destination);
 
-        IDiGraph<T> Clone();
-        
+        IDiGraph<T> Clone();      
     }
 
     public interface IDiGraphVertex<T>
     {
-        T Value { get; }
+        T Key { get; }
         IEnumerable<IDiEdge<T>> OutEdges { get; }
         IEnumerable<IDiEdge<T>> InEdges { get; }
 
         IDiEdge<T> GetOutEdge(IDiGraphVertex<T> targetVertex);
 
         int OutEdgeCount { get; }
         int InEdgeCount { get; }
-
-      
     }
 
     public interface IDiEdge<T>
     {
         W Weight<W>() where W : IComparable;
-        T Value { get; }
-        IDiGraphVertex<T> Target { get; }
+        T TargetVertexKey { get; }
+        IDiGraphVertex<T> TargetVertex { get; }
     }
 
     internal class DiEdge<T, C> : IDiEdge<T> where C : IComparable
     {
-        private IDiGraphVertex<T> target;
         private object weight;
 
         internal DiEdge(IDiGraphVertex<T> target, C weight)
         {
-            this.target = target;
+            TargetVertex = target;
             this.weight = weight;
         }
 
-        public T Value => target.Value;
+        public T TargetVertexKey => TargetVertex.Key;
 
-        public IDiGraphVertex<T> Target => target;
+        public IDiGraphVertex<T> TargetVertex { get; private set; }
 
         public W Weight<W>() where W : IComparable
         {
 
@@ -8,11 +8,13 @@ namespace Advanced.Algorithms.DataStructures.Graph
 {
     public interface IGraph<T> : IEnumerable<IGraphVertex<T>>
     {
+        bool IsWeightedGraph { get; }
+
         int VerticesCount { get; }
 
         IGraphVertex<T> ReferenceVertex { get; }
-        bool ContainsVertex(T value);
-        IGraphVertex<T> GetVertex(T value);
+        bool ContainsVertex(T key);
+        IGraphVertex<T> GetVertex(T key);
 
         bool HasEdge(T source, T destination);
 
@@ -21,31 +23,30 @@ public interface IGraph<T> : IEnumerable<IGraphVertex<T>>
 
     public interface IGraphVertex<T>
     {
-        T Value { get; }
+        T Key { get; }
         IEnumerable<IEdge<T>> Edges { get; }
     }
 
     public interface IEdge<T>
     {
         W Weight<W>() where W : IComparable;
-        T Value { get; }
-        IGraphVertex<T> Target { get; }
+        T TargetVertexKey { get; }
+        IGraphVertex<T> TargetVertex { get; }
     }
 
     internal class Edge<T, C> : IEdge<T> where C : IComparable
     {
-        private IGraphVertex<T> target;
         private object weight;
 
         internal Edge(IGraphVertex<T> target, C weight)
         {
-            this.target = target;
+            this.TargetVertex = target;
             this.weight = weight;
         }
 
-        public T Value => target.Value;
+        public T TargetVertexKey => TargetVertex.Key;
 
-        public IGraphVertex<T> Target => target;
+        public IGraphVertex<T> TargetVertex { get; private set; }
 
         public W Weight<W>() where W : IComparable
         {
Original file line number	Diff line number	Diff line change
`@@ -13,6 +13,7 @@ public class DiGraph<T> : IDiGraph<T>`
`13`	`13`	`{`
`14`	`14`	`public int VerticesCount => Vertices.Count;`
`15`	`15`	`internal Dictionary<T, DiGraphVertex<T>> Vertices { get; set; }`
	`16`	`+ public bool IsWeightedGraph => false;`
`16`	`17`
`17`	`18`	`public DiGraph()`
`18`	`19`	`{`
`@@ -41,8 +42,7 @@ public DiGraphVertex<T> ReferenceVertex`
`41`	`42`	`}`
`42`	`43`
`43`	`44`	`IDiGraphVertex<T> IDiGraph<T>.ReferenceVertex => ReferenceVertex;`
`44`		`-`
`45`		`-`
	`45`	`+`
`46`	`46`	`/// <summary>`
`47`	`47`	`/// Add a new vertex to this graph.`
`48`	`48`	`/// Time complexity: O(1).`
`@@ -163,7 +163,7 @@ public IEnumerable<T> OutEdges(T vertex)`
`163`	`163`	`throw new ArgumentException("vertex is not in this graph.");`
`164`	`164`	`}`
`165`	`165`
`166`		`- return Vertices[vertex].OutEdges.Select(x => x.Value);`
	`166`	`+ return Vertices[vertex].OutEdges.Select(x => x.Key);`
`167`	`167`	`}`
`168`	`168`
`169`	`169`	`public IEnumerable<T> InEdges(T vertex)`
`@@ -173,7 +173,7 @@ public IEnumerable<T> InEdges(T vertex)`
`173`	`173`	`throw new ArgumentException("vertex is not in this graph.");`
`174`	`174`	`}`
`175`	`175`
`176`		`- return Vertices[vertex].InEdges.Select(x => x.Value);`
	`176`	`+ return Vertices[vertex].InEdges.Select(x => x.Key);`
`177`	`177`	`}`
`178`	`178`
`179`	`179`	`/// <summary>`
`@@ -201,7 +201,7 @@ public DiGraph<T> Clone()`
`201`	`201`	`{`
`202`	`202`	`foreach (var edge in vertex.Value.OutEdges)`
`203`	`203`	`{`
`204`		`- newGraph.AddEdge(vertex.Value.Value, edge.Value);`
	`204`	`+ newGraph.AddEdge(vertex.Value.Key, edge.Key);`
`205`	`205`	`}`
`206`	`206`	`}`
`207`	`207`
`@@ -218,6 +218,11 @@ public IDiGraphVertex<T> GetVertex(T value)`
`218`	`218`	`return Vertices[value];`
`219`	`219`	`}`
`220`	`220`
	`221`	`+ IDiGraph<T> IDiGraph<T>.Clone()`
	`222`	`+ {`
	`223`	`+ return Clone();`
	`224`	`+ }`
	`225`	`+`
`221`	`226`	`IEnumerator<IDiGraphVertex<T>> IEnumerable<IDiGraphVertex<T>>.GetEnumerator()`
`222`	`227`	`{`
`223`	`228`	`return GetEnumerator() as IEnumerator<IDiGraphVertex<T>>;`
`@@ -228,10 +233,6 @@ public IEnumerator GetEnumerator()`
`228`	`233`	`return Vertices.Select(x => x.Value).GetEnumerator();`
`229`	`234`	`}`
`230`	`235`
`231`		`- IDiGraph<T> IDiGraph<T>.Clone()`
`232`		`- {`
`233`		`- throw new NotImplementedException();`
`234`		`- }`
`235`	`236`	`}`
`236`	`237`
`237`	`238`	`/// <summary>`
`@@ -240,7 +241,7 @@ IDiGraph<T> IDiGraph<T>.Clone()`
`240`	`241`	`/// </summary>`
`241`	`242`	`public class DiGraphVertex<T> : IDiGraphVertex<T>, IEnumerable<T>`
`242`	`243`	`{`
`243`		`- public T Value { get; set; }`
	`244`	`+ public T Key { get; set; }`
`244`	`245`
`245`	`246`	`public HashSet<DiGraphVertex<T>> OutEdges { get; set; }`
`246`	`247`	`public HashSet<DiGraphVertex<T>> InEdges { get; set; }`
`@@ -253,7 +254,7 @@ public class DiGraphVertex<T> : IDiGraphVertex<T>, IEnumerable<T>`
`253`	`254`
`254`	`255`	`public DiGraphVertex(T value)`
`255`	`256`	`{`
`256`		`- Value = value;`
	`257`	`+ Key = value;`
`257`	`258`	`OutEdges = new HashSet<DiGraphVertex<T>>();`
`258`	`259`	`InEdges = new HashSet<DiGraphVertex<T>>();`
`259`	`260`	`}`
`@@ -271,7 +272,7 @@ IEnumerator IEnumerable.GetEnumerator()`
`271`	`272`
`272`	`273`	`public IEnumerator<T> GetEnumerator()`
`273`	`274`	`{`
`274`		`- return OutEdges.Select(x => x.Value).GetEnumerator();`
	`275`	`+ return OutEdges.Select(x => x.Key).GetEnumerator();`
`275`	`276`	`}`
`276`	`277`
`277`	`278`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,6 +13,7 @@ public class Graph<T> : IGraph<T>`
`13`	`13`	`{`
`14`	`14`	`public int VerticesCount => Vertices.Count;`
`15`	`15`	`internal Dictionary<T, GraphVertex<T>> Vertices { get; set; }`
	`16`	`+ public bool IsWeightedGraph => false;`
`16`	`17`
`17`	`18`	`public Graph()`
`18`	`19`	`{`
`@@ -159,7 +160,7 @@ public IEnumerable<T> Edges(T vertex)`
`159`	`160`	`throw new ArgumentException("vertex is not in this graph.");`
`160`	`161`	`}`
`161`	`162`
`162`		`- return Vertices[vertex].Edges.Select(x => x.Value);`
	`163`	`+ return Vertices[vertex].Edges.Select(x => x.Key);`
`163`	`164`	`}`
`164`	`165`
`165`	`166`	`/// <summary>`
`@@ -202,7 +203,7 @@ public Graph<T> Clone()`
`202`	`203`	`{`
`203`	`204`	`foreach (var edge in vertex.Value.Edges)`
`204`	`205`	`{`
`205`		`- newGraph.AddEdge(vertex.Value.Value, edge.Value);`
	`206`	`+ newGraph.AddEdge(vertex.Value.Key, edge.Key);`
`206`	`207`	`}`
`207`	`208`	`}`
`208`	`209`
`@@ -231,15 +232,15 @@ IGraph<T> IGraph<T>.Clone()`
`231`	`232`	`/// </summary>`
`232`	`233`	`public class GraphVertex<T> : IEnumerable<T>, IGraphVertex<T>`
`233`	`234`	`{`
`234`		`- public T Value { get; set; }`
	`235`	`+ public T Key { get; set; }`
`235`	`236`
`236`	`237`	`public HashSet<GraphVertex<T>> Edges { get; set; }`
`237`	`238`
`238`	`239`	`IEnumerable<IEdge<T>> IGraphVertex<T>.Edges => Edges.Select(x => new Edge<T, int>(x, 1));`
`239`	`240`
`240`	`241`	`public GraphVertex(T value)`
`241`	`242`	`{`
`242`		`- Value = value;`
	`243`	`+ Key = value;`
`243`	`244`	`Edges = new HashSet<GraphVertex<T>>();`
`244`	`245`	`}`
`245`	`246`
`@@ -250,7 +251,7 @@ IEnumerator IEnumerable.GetEnumerator()`
`250`	`251`
`251`	`252`	`public IEnumerator<T> GetEnumerator()`
`252`	`253`	`{`
`253`		`- return Edges.Select(x => x.Value).GetEnumerator();`
	`254`	`+ return Edges.Select(x => x.Key).GetEnumerator();`
`254`	`255`	`}`
`255`	`256`	`}`
`256`	`257`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,6 +13,7 @@ public class WeightedDiGraph<T, TW> : IDiGraph<T> where TW : IComparable`
`13`	`13`	`{`
`14`	`14`	`public int VerticesCount => Vertices.Count;`
`15`	`15`	`internal Dictionary<T, WeightedDiGraphVertex<T, TW>> Vertices { get; set; }`
	`16`	`+ public bool IsWeightedGraph => true;`
`16`	`17`
`17`	`18`	`public WeightedDiGraph()`
`18`	`19`	`{`
`@@ -164,7 +165,7 @@ public IEnumerable<Tuple<T, TW>> OutEdges(T vertex)`
`164`	`165`	`throw new ArgumentException("vertex is not in this graph.");`
`165`	`166`	`}`
`166`	`167`
`167`		`- return Vertices[vertex].OutEdges.Select(x => new Tuple<T, TW>(x.Key.Value, x.Value));`
	`168`	`+ return Vertices[vertex].OutEdges.Select(x => new Tuple<T, TW>(x.Key.Key, x.Value));`
`168`	`169`	`}`
`169`	`170`
`170`	`171`	`public IEnumerable<Tuple<T, TW>> InEdges(T vertex)`
`@@ -174,7 +175,7 @@ public IEnumerable<Tuple<T, TW>> InEdges(T vertex)`
`174`	`175`	`throw new ArgumentException("vertex is not in this graph.");`
`175`	`176`	`}`
`176`	`177`
`177`		`- return Vertices[vertex].InEdges.Select(x => new Tuple<T, TW>(x.Key.Value, x.Value));`
	`178`	`+ return Vertices[vertex].InEdges.Select(x => new Tuple<T, TW>(x.Key.Key, x.Value));`
`178`	`179`	`}`
`179`	`180`
`180`	`181`	`/// <summary>`
`@@ -217,7 +218,7 @@ public WeightedDiGraph<T, TW> Clone()`
`217`	`218`	`{`
`218`	`219`	`foreach (var edge in vertex.Value.OutEdges)`
`219`	`220`	`{`
`220`		`- newGraph.AddEdge(vertex.Value.Value, edge.Key.Value, edge.Value);`
	`221`	`+ newGraph.AddEdge(vertex.Value.Key, edge.Key.Key, edge.Value);`
`221`	`222`	`}`
`222`	`223`	`}`
`223`	`224`
`@@ -246,7 +247,7 @@ IDiGraph<T> IDiGraph<T>.Clone()`
`246`	`247`	`/// </summary>`
`247`	`248`	`public class WeightedDiGraphVertex<T, TW> : IDiGraphVertex<T>, IEnumerable<T> where TW : IComparable`
`248`	`249`	`{`
`249`		`- public T Value { get; private set; }`
	`250`	`+ public T Key { get; private set; }`
`250`	`251`
`251`	`252`	`public Dictionary<WeightedDiGraphVertex<T, TW>, TW> OutEdges { get; set; }`
`252`	`253`	`public Dictionary<WeightedDiGraphVertex<T, TW>, TW> InEdges { get; set; }`
`@@ -259,7 +260,7 @@ public class WeightedDiGraphVertex<T, TW> : IDiGraphVertex<T>, IEnumerable<T> wh`
`259`	`260`
`260`	`261`	`public WeightedDiGraphVertex(T value)`
`261`	`262`	`{`
`262`		`- Value = value;`
	`263`	`+ Key = value;`
`263`	`264`
`264`	`265`	`OutEdges = new Dictionary<WeightedDiGraphVertex<T, TW>, TW>();`
`265`	`266`	`InEdges = new Dictionary<WeightedDiGraphVertex<T, TW>, TW>();`
`@@ -278,7 +279,7 @@ IEnumerator IEnumerable.GetEnumerator()`
`278`	`279`
`279`	`280`	`public IEnumerator<T> GetEnumerator()`
`280`	`281`	`{`
`281`		`- return OutEdges.Select(x => x.Key.Value).GetEnumerator();`
	`282`	`+ return OutEdges.Select(x => x.Key.Key).GetEnumerator();`
`282`	`283`	`}`
`283`	`284`
`284`	`285`
Original file line number	Diff line number	Diff line change
`@@ -1,60 +1,55 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.Collections.Generic;`
`3`		`-using System.Linq;`
`4`		`-using System.Text;`
`5`		`-using System.Threading.Tasks;`
`6`	`3`
`7`	`4`	`namespace Advanced.Algorithms.DataStructures.Graph`
`8`	`5`	`{`
`9`	`6`	`public interface IDiGraph<T> : IEnumerable<IDiGraphVertex<T>>`
`10`	`7`	`{`
	`8`	`+ bool IsWeightedGraph { get; }`
	`9`	`+`
`11`	`10`	`bool ContainsVertex(T value);`
`12`		`- IDiGraphVertex<T> GetVertex(T value);`
	`11`	`+ IDiGraphVertex<T> GetVertex(T key);`
`13`	`12`	`IDiGraphVertex<T> ReferenceVertex { get; }`
`14`	`13`
`15`	`14`	`int VerticesCount { get; }`
`16`	`15`
`17`	`16`	`bool HasEdge(T source, T destination);`
`18`	`17`
`19`		`- IDiGraph<T> Clone();`
`20`		`-`
	`18`	`+ IDiGraph<T> Clone();`
`21`	`19`	`}`
`22`	`20`
`23`	`21`	`public interface IDiGraphVertex<T>`
`24`	`22`	`{`
`25`		`- T Value { get; }`
	`23`	`+ T Key { get; }`
`26`	`24`	`IEnumerable<IDiEdge<T>> OutEdges { get; }`
`27`	`25`	`IEnumerable<IDiEdge<T>> InEdges { get; }`
`28`	`26`
`29`	`27`	`IDiEdge<T> GetOutEdge(IDiGraphVertex<T> targetVertex);`
`30`	`28`
`31`	`29`	`int OutEdgeCount { get; }`
`32`	`30`	`int InEdgeCount { get; }`
`33`		`-`
`34`		`-`
`35`	`31`	`}`
`36`	`32`
`37`	`33`	`public interface IDiEdge<T>`
`38`	`34`	`{`
`39`	`35`	`W Weight<W>() where W : IComparable;`
`40`		`- T Value { get; }`
`41`		`- IDiGraphVertex<T> Target { get; }`
	`36`	`+ T TargetVertexKey { get; }`
	`37`	`+ IDiGraphVertex<T> TargetVertex { get; }`
`42`	`38`	`}`
`43`	`39`
`44`	`40`	`internal class DiEdge<T, C> : IDiEdge<T> where C : IComparable`
`45`	`41`	`{`
`46`		`- private IDiGraphVertex<T> target;`
`47`	`42`	`private object weight;`
`48`	`43`
`49`	`44`	`internal DiEdge(IDiGraphVertex<T> target, C weight)`
`50`	`45`	`{`
`51`		`- this.target = target;`
	`46`	`+ TargetVertex = target;`
`52`	`47`	`this.weight = weight;`
`53`	`48`	`}`
`54`	`49`
`55`		`- public T Value => target.Value;`
	`50`	`+ public T TargetVertexKey => TargetVertex.Key;`
`56`	`51`
`57`		`- public IDiGraphVertex<T> Target => target;`
	`52`	`+ public IDiGraphVertex<T> TargetVertex { get; private set; }`
`58`	`53`
`59`	`54`	`public W Weight<W>() where W : IComparable`
`60`	`55`	`{`
Original file line number	Diff line number	Diff line change
`@@ -8,11 +8,13 @@ namespace Advanced.Algorithms.DataStructures.Graph`
`8`	`8`	`{`
`9`	`9`	`public interface IGraph<T> : IEnumerable<IGraphVertex<T>>`
`10`	`10`	`{`
	`11`	`+ bool IsWeightedGraph { get; }`
	`12`	`+`
`11`	`13`	`int VerticesCount { get; }`
`12`	`14`
`13`	`15`	`IGraphVertex<T> ReferenceVertex { get; }`
`14`		`- bool ContainsVertex(T value);`
`15`		`- IGraphVertex<T> GetVertex(T value);`
	`16`	`+ bool ContainsVertex(T key);`
	`17`	`+ IGraphVertex<T> GetVertex(T key);`
`16`	`18`
`17`	`19`	`bool HasEdge(T source, T destination);`
`18`	`20`
`@@ -21,31 +23,30 @@ public interface IGraph<T> : IEnumerable<IGraphVertex<T>>`
`21`	`23`
`22`	`24`	`public interface IGraphVertex<T>`
`23`	`25`	`{`
`24`		`- T Value { get; }`
	`26`	`+ T Key { get; }`
`25`	`27`	`IEnumerable<IEdge<T>> Edges { get; }`
`26`	`28`	`}`
`27`	`29`
`28`	`30`	`public interface IEdge<T>`
`29`	`31`	`{`
`30`	`32`	`W Weight<W>() where W : IComparable;`
`31`		`- T Value { get; }`
`32`		`- IGraphVertex<T> Target { get; }`
	`33`	`+ T TargetVertexKey { get; }`
	`34`	`+ IGraphVertex<T> TargetVertex { get; }`
`33`	`35`	`}`
`34`	`36`
`35`	`37`	`internal class Edge<T, C> : IEdge<T> where C : IComparable`
`36`	`38`	`{`
`37`		`- private IGraphVertex<T> target;`
`38`	`39`	`private object weight;`
`39`	`40`
`40`	`41`	`internal Edge(IGraphVertex<T> target, C weight)`
`41`	`42`	`{`
`42`		`- this.target = target;`
	`43`	`+ this.TargetVertex = target;`
`43`	`44`	`this.weight = weight;`
`44`	`45`	`}`
`45`	`46`
`46`		`- public T Value => target.Value;`
	`47`	`+ public T TargetVertexKey => TargetVertex.Key;`
`47`	`48`
`48`		`- public IGraphVertex<T> Target => target;`
	`49`	`+ public IGraphVertex<T> TargetVertex { get; private set; }`
`49`	`50`
`50`	`51`	`public W Weight<W>() where W : IComparable`
`51`	`52`	`{`