Let undirected graph algorithms run on directed graphs

justcoding121 · justcoding121 · commit 19698c49194b · 2019-04-22T17:59:49.000-04:00
diff --git a/src/Advanced.Algorithms/DataStructures/Graph/AdjacencyList/DiGraph.cs b/src/Advanced.Algorithms/DataStructures/Graph/AdjacencyList/DiGraph.cs
@@ -9,7 +9,7 @@ namespace Advanced.Algorithms.DataStructures.Graph.AdjacencyList
     /// A directed graph implementation.
     /// IEnumerable enumerates all vertices.
     /// </summary>
-    public class DiGraph<T> : IDiGraph<T>
+    public class DiGraph<T> : IGraph<T>, IDiGraph<T>, IEnumerable<T>
     {
         public int VerticesCount => Vertices.Count;
         internal Dictionary<T, DiGraphVertex<T>> Vertices { get; set; }
@@ -42,7 +42,9 @@ public DiGraphVertex<T> ReferenceVertex
         }
 
         IDiGraphVertex<T> IDiGraph<T>.ReferenceVertex => ReferenceVertex;
-        
+        IGraphVertex<T> IGraph<T>.ReferenceVertex => ReferenceVertex;
+
+       
         /// <summary>
         /// Add a new vertex to this graph.
         /// Time complexity: O(1).
@@ -218,28 +220,40 @@ public IDiGraphVertex<T> GetVertex(T value)
             return Vertices[value];
         }
 
+        IGraphVertex<T> IGraph<T>.GetVertex(T key)
+        {
+            return Vertices[key];
+        }
+
         IDiGraph<T> IDiGraph<T>.Clone()
         {
             return Clone();
         }
 
-        IEnumerator<IDiGraphVertex<T>> IEnumerable<IDiGraphVertex<T>>.GetEnumerator()
+        IGraph<T> IGraph<T>.Clone()
         {
-            return GetEnumerator() as IEnumerator<IDiGraphVertex<T>>;
+            return Clone();
         }
 
         public IEnumerator GetEnumerator()
         {
-            return Vertices.Select(x => x.Value).GetEnumerator();
+            return Vertices.Select(x => x.Key).GetEnumerator(); 
         }
 
+        IEnumerator<T> IEnumerable<T>.GetEnumerator()
+        {
+            return GetEnumerator() as IEnumerator<T>;
+        }
+
+        public IEnumerable<IGraphVertex<T>> VerticesAsEnumberable => Vertices.Select(x => x.Value);
+        IEnumerable<IDiGraphVertex<T>> IDiGraph<T>.VerticesAsEnumberable => Vertices.Select(x => x.Value);
     }
 
     /// <summary>
     /// DiGraph vertex for adjacency list Graph implementation. 
     /// IEnumerable enumerates all the outgoing edge destination vertices.
     /// </summary>
-    public class DiGraphVertex<T> : IDiGraphVertex<T>, IEnumerable<T>
+    public class DiGraphVertex<T> : IDiGraphVertex<T>, IGraphVertex<T>, IEnumerable<T>
     {
         public T Key { get; set; }
 
@@ -252,6 +266,8 @@ public class DiGraphVertex<T> : IDiGraphVertex<T>, IEnumerable<T>
         public int OutEdgeCount => OutEdges.Count;
         public int InEdgeCount => InEdges.Count;
 
+        IEnumerable<IEdge<T>> IGraphVertex<T>.Edges => OutEdges.Select(x => new Edge<T, int>(x, 1));
+
         public DiGraphVertex(T value)
         {
             Key = value;
diff --git a/src/Advanced.Algorithms/DataStructures/Graph/AdjacencyList/Graph.cs b/src/Advanced.Algorithms/DataStructures/Graph/AdjacencyList/Graph.cs
@@ -9,7 +9,7 @@ namespace Advanced.Algorithms.DataStructures.Graph.AdjacencyList
     /// A graph implementation
     /// IEnumerable enumerates all vertices.
     /// </summary>
-    public class Graph<T> : IGraph<T>
+    public class Graph<T> : IGraph<T>, IEnumerable<T>
     {
         public int VerticesCount => Vertices.Count;
         internal Dictionary<T, GraphVertex<T>> Vertices { get; set; }
@@ -210,20 +210,22 @@ public Graph<T> Clone()
             return newGraph;
         }
 
-        IEnumerator<IGraphVertex<T>> IEnumerable<IGraphVertex<T>>.GetEnumerator()
+        public IEnumerator GetEnumerator()
         {
-            return GetEnumerator() as IEnumerator<IGraphVertex<T>>;
+            return Vertices.Select(x => x.Key).GetEnumerator();
         }
 
-        public IEnumerator GetEnumerator()
+        IEnumerator<T> IEnumerable<T>.GetEnumerator()
         {
-            return Vertices.Select(x => x.Value).GetEnumerator();
+            return GetEnumerator() as IEnumerator<T>;
         }
 
         IGraph<T> IGraph<T>.Clone()
         {
             return Clone();
         }
+
+        public IEnumerable<IGraphVertex<T>> VerticesAsEnumberable => Vertices.Select(x => x.Value);
     }
 
     /// <summary>
diff --git a/src/Advanced.Algorithms/DataStructures/Graph/AdjacencyList/WeightedDiGraph.cs b/src/Advanced.Algorithms/DataStructures/Graph/AdjacencyList/WeightedDiGraph.cs
@@ -9,7 +9,7 @@ namespace Advanced.Algorithms.DataStructures.Graph.AdjacencyList
     /// A weighted graph implementation.
     /// IEnumerable enumerates all vertices.
     /// </summary>
-    public class WeightedDiGraph<T, TW> : IDiGraph<T> where TW : IComparable
+    public class WeightedDiGraph<T, TW> : IDiGraph<T>, IGraph<T>, IEnumerable<T> where TW : IComparable
     {
         public int VerticesCount => Vertices.Count;
         internal Dictionary<T, WeightedDiGraphVertex<T, TW>> Vertices { get; set; }
@@ -41,6 +41,7 @@ public WeightedDiGraphVertex<T, TW> ReferenceVertex
         }
 
         IDiGraphVertex<T> IDiGraph<T>.ReferenceVertex => ReferenceVertex;
+        IGraphVertex<T> IGraph<T>.ReferenceVertex => ReferenceVertex;
 
         /// <summary>
         /// Add a new vertex to this graph.
@@ -197,9 +198,14 @@ public bool ContainsVertex(T value)
             return Vertices.ContainsKey(value);
         }
 
-        public IDiGraphVertex<T> GetVertex(T value)
+        IGraphVertex<T> IGraph<T>.GetVertex(T key)
         {
-            return Vertices[value];
+            return Vertices[key];
+        }
+
+        public IDiGraphVertex<T> GetVertex(T key)
+        {
+            return Vertices[key];
         }
 
         /// <summary>
@@ -225,27 +231,35 @@ public WeightedDiGraph<T, TW> Clone()
             return newGraph;
         }
 
-        IEnumerator<IDiGraphVertex<T>> IEnumerable<IDiGraphVertex<T>>.GetEnumerator()
+        IDiGraph<T> IDiGraph<T>.Clone()
         {
-            return GetEnumerator() as IEnumerator<IDiGraphVertex<T>>;
+            return Clone();
+        }
+
+        IGraph<T> IGraph<T>.Clone()
+        {
+            return Clone();
         }
 
         public IEnumerator GetEnumerator()
         {
-            return Vertices.Select(x => x.Value).GetEnumerator();
+            return Vertices.Select(x => x.Key).GetEnumerator();
         }
 
-        IDiGraph<T> IDiGraph<T>.Clone()
+        IEnumerator<T> IEnumerable<T>.GetEnumerator()
         {
-            return Clone();
+            return GetEnumerator() as IEnumerator<T>;
         }
+
+        public IEnumerable<IGraphVertex<T>> VerticesAsEnumberable => Vertices.Select(x => x.Value);
+        IEnumerable<IDiGraphVertex<T>> IDiGraph<T>.VerticesAsEnumberable => Vertices.Select(x => x.Value);
     }
 
     /// <summary>
     /// A weighted graph vertex for adjacency list Graph implementation. 
     /// IEnumerable enumerates all the outgoing edge destination vertices.
     /// </summary>
-    public class WeightedDiGraphVertex<T, TW> : IDiGraphVertex<T>, IEnumerable<T> where TW : IComparable
+    public class WeightedDiGraphVertex<T, TW> : IDiGraphVertex<T>, IGraphVertex<T>, IEnumerable<T> where TW : IComparable
     {
         public T Key { get; private set; }
 
@@ -258,6 +272,8 @@ public class WeightedDiGraphVertex<T, TW> : IDiGraphVertex<T>, IEnumerable<T> wh
         public int OutEdgeCount => OutEdges.Count;
         public int InEdgeCount => InEdges.Count;
 
+        IEnumerable<IEdge<T>> IGraphVertex<T>.Edges => OutEdges.Select(x => new Edge<T, TW>(x.Key, x.Value));
+
         public WeightedDiGraphVertex(T value)
         {
             Key = value;
diff --git a/src/Advanced.Algorithms/DataStructures/Graph/AdjacencyList/WeightedGraph.cs b/src/Advanced.Algorithms/DataStructures/Graph/AdjacencyList/WeightedGraph.cs
@@ -9,7 +9,7 @@ namespace Advanced.Algorithms.DataStructures.Graph.AdjacencyList
     /// A weighted graph implementation.
     /// IEnumerable enumerates all vertices.
     /// </summary>
-    public class WeightedGraph<T, TW> : IGraph<T> where TW : IComparable
+    public class WeightedGraph<T, TW> : IGraph<T>, IEnumerable<T> where TW : IComparable
     {
         public int VerticesCount => Vertices.Count;
         internal Dictionary<T, WeightedGraphVertex<T, TW>> Vertices { get; set; }
@@ -207,20 +207,22 @@ public WeightedGraph<T, TW> Clone()
             return newGraph;
         }
 
-        IEnumerator<IGraphVertex<T>> IEnumerable<IGraphVertex<T>>.GetEnumerator()
+        public IEnumerator GetEnumerator()
         {
-            return GetEnumerator() as IEnumerator<IGraphVertex<T>>;
+            return Vertices.Select(x => x.Key).GetEnumerator();
         }
 
-        public IEnumerator GetEnumerator()
+        IEnumerator<T> IEnumerable<T>.GetEnumerator()
         {
-            return Vertices.Select(x => x.Value).GetEnumerator();
+            return GetEnumerator() as IEnumerator<T>;
         }
 
         IGraph<T> IGraph<T>.Clone()
         {
             return Clone();
         }
+
+        public IEnumerable<IGraphVertex<T>> VerticesAsEnumberable => Vertices.Select(x => x.Value);
     }
 
     /// <summary>
diff --git a/src/Advanced.Algorithms/DataStructures/Graph/IDiGraph.cs b/src/Advanced.Algorithms/DataStructures/Graph/IDiGraph.cs
@@ -3,14 +3,18 @@
 
 namespace Advanced.Algorithms.DataStructures.Graph
 {
-    public interface IDiGraph<T> : IEnumerable<IDiGraphVertex<T>>
+    /// <summary>
+    /// Directed graph. 
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    public interface IDiGraph<T> 
     {
         bool IsWeightedGraph { get; }
 
         bool ContainsVertex(T value);
         IDiGraphVertex<T> GetVertex(T key);
         IDiGraphVertex<T> ReferenceVertex { get; }
-
+        IEnumerable<IDiGraphVertex<T>> VerticesAsEnumberable { get; }
         int VerticesCount { get; }
 
         bool HasEdge(T source, T destination);
diff --git a/src/Advanced.Algorithms/DataStructures/Graph/IGraph.cs b/src/Advanced.Algorithms/DataStructures/Graph/IGraph.cs
@@ -6,15 +6,19 @@
 
 namespace Advanced.Algorithms.DataStructures.Graph
 {
-    public interface IGraph<T> : IEnumerable<IGraphVertex<T>>
+    /// <summary>
+    /// UnDirected graph. 
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    public interface IGraph<T>
     {
         bool IsWeightedGraph { get; }
 
         int VerticesCount { get; }
-
         IGraphVertex<T> ReferenceVertex { get; }
         bool ContainsVertex(T key);
         IGraphVertex<T> GetVertex(T key);
+        IEnumerable<IGraphVertex<T>> VerticesAsEnumberable { get; }
 
         bool HasEdge(T source, T destination);
 
diff --git a/src/Advanced.Algorithms/Graph/Connectivity/KosarajuStronglyConnected.cs b/src/Advanced.Algorithms/Graph/Connectivity/KosarajuStronglyConnected.cs
@@ -19,7 +19,7 @@ public List<List<T>>
             var finishStack = new Stack<T>();
 
             //step one - create DFS finish visit stack
-            foreach (var vertex in graph)
+            foreach (var vertex in graph.VerticesAsEnumberable)
             {
                 if(!visited.Contains(vertex.Key))
                 {
@@ -98,12 +98,12 @@ private IDiGraph<T> reverseEdges(IDiGraph<T> graph)
         {
             var newGraph = new DiGraph<T>();
 
-            foreach (var vertex in graph)
+            foreach (var vertex in graph.VerticesAsEnumberable)
             {
                 newGraph.AddVertex(vertex.Key);
             }
 
-            foreach (var vertex in graph)
+            foreach (var vertex in graph.VerticesAsEnumberable)
             {
                 foreach (var edge in vertex.OutEdges)
                 {
diff --git a/src/Advanced.Algorithms/Graph/Connectivity/TarjansStronglyConnected.cs b/src/Advanced.Algorithms/Graph/Connectivity/TarjansStronglyConnected.cs
@@ -22,7 +22,7 @@ public List<List<T>> FindStronglyConnectedComponents(IDiGraph<T> graph)
             var pathStack = new Stack<T>();
             var pathStackMap = new HashSet<T>();
             var discoveryTime = 0;
-            foreach (var vertex in graph)
+            foreach (var vertex in graph.VerticesAsEnumberable)
             {
                 if (!discoveryTimeMap.ContainsKey(vertex.Key))
                 {
diff --git a/src/Advanced.Algorithms/Graph/Flow/EdmondsKarp.cs b/src/Advanced.Algorithms/Graph/Flow/EdmondsKarp.cs
@@ -228,13 +228,13 @@ private WeightedDiGraph<T, W> createResidualGraph(IDiGraph<T> graph)
             var newGraph = new WeightedDiGraph<T, W>();
 
             //clone graph vertices
-            foreach (var vertex in graph)
+            foreach (var vertex in graph.VerticesAsEnumberable)
             {
                 newGraph.AddVertex(vertex.Key);
             }
 
             //clone edges
-            foreach (var vertex in graph)
+            foreach (var vertex in graph.VerticesAsEnumberable)
             {
                 //Use either OutEdges or InEdges for cloning
                 //here we use OutEdges
diff --git a/src/Advanced.Algorithms/Graph/Flow/FordFulkerson.cs b/src/Advanced.Algorithms/Graph/Flow/FordFulkerson.cs
@@ -207,13 +207,13 @@ private WeightedDiGraph<T, W> createResidualGraph(IDiGraph<T> graph)
             var newGraph = new WeightedDiGraph<T, W>();
 
             //clone graph vertices
-            foreach (var vertex in graph)
+            foreach (var vertex in graph.VerticesAsEnumberable)
             {
                 newGraph.AddVertex(vertex.Key);
             }
 
             //clone edges
-            foreach (var vertex in graph)
+            foreach (var vertex in graph.VerticesAsEnumberable)
             {
                 //Use either OutEdges or InEdges for cloning
                 //here we use OutEdges
diff --git a/src/Advanced.Algorithms/Graph/Flow/PushRelabel.cs b/src/Advanced.Algorithms/Graph/Flow/PushRelabel.cs
@@ -189,13 +189,13 @@ private WeightedDiGraph<T, W> createResidualGraph(IDiGraph<T> graph)
             var newGraph = new WeightedDiGraph<T, W>();
 
             //clone graph vertices
-            foreach (var vertex in graph)
+            foreach (var vertex in graph.VerticesAsEnumberable)
             {
                 newGraph.AddVertex(vertex.Key);
             }
 
             //clone edges
-            foreach (var vertex in graph)
+            foreach (var vertex in graph.VerticesAsEnumberable)
             {
                 //Use either OutEdges or InEdges for cloning
                 //here we use OutEdges
diff --git a/src/Advanced.Algorithms/Graph/MinimumSpanningTree/Kruskals.cs b/src/Advanced.Algorithms/Graph/MinimumSpanningTree/Kruskals.cs
@@ -40,7 +40,7 @@ public List<MSTEdge<T, W>>
             var disJointSet = new DisJointSet<T>();
 
             //create set
-            foreach (var vertex in graph)
+            foreach (var vertex in graph.VerticesAsEnumberable)
             {
                 disJointSet.MakeSet(vertex.Key);
             }
diff --git a/src/Advanced.Algorithms/Graph/ShortestPath/AStar.cs b/src/Advanced.Algorithms/Graph/ShortestPath/AStar.cs
@@ -58,7 +58,7 @@ public ShortestPathResult<T, W> FindShortestPath(IDiGraph<T> graph, T source, T
             var heapMapping = new Dictionary<T, AStarWrap<T, W>>();
 
             //add vertices to min heap and progress map
-            foreach (var vertex in graph)
+            foreach (var vertex in graph.VerticesAsEnumberable)
             {
                 //init parent
                 parentMap.Add(vertex.Key, default(T));
diff --git a/src/Advanced.Algorithms/Graph/ShortestPath/Bellman-Ford.cs b/src/Advanced.Algorithms/Graph/ShortestPath/Bellman-Ford.cs
@@ -46,7 +46,7 @@ public ShortestPathResult<T, W> FindShortestPath(IDiGraph<T> graph,
             var progress = new Dictionary<T, W>();
             var parentMap = new Dictionary<T, T>();
 
-            foreach (var vertex in graph)
+            foreach (var vertex in graph.VerticesAsEnumberable)
             {
                 parentMap.Add(vertex.Key, default(T));
                 progress.Add(vertex.Key, @operator.MaxValue);
@@ -61,7 +61,7 @@ public ShortestPathResult<T, W> FindShortestPath(IDiGraph<T> graph,
             {
                 updated = false;
 
-                foreach (var vertex in graph)
+                foreach (var vertex in graph.VerticesAsEnumberable)
                 {
                     //skip not discovered nodes
                     if (progress[vertex.Key].Equals(@operator.MaxValue))
diff --git a/src/Advanced.Algorithms/Graph/ShortestPath/Dijikstra.cs b/src/Advanced.Algorithms/Graph/ShortestPath/Dijikstra.cs
@@ -55,7 +55,7 @@ public ShortestPathResult<T, W> FindShortestPath(IDiGraph<T> graph, T source, T
             var heapMapping = new Dictionary<T, MinHeapWrap<T, W>>();
 
             //add vertices to min heap and progress map
-            foreach (var vertex in graph)
+            foreach (var vertex in graph.VerticesAsEnumberable)
             {
                 //init parent
                 parentMap.Add(vertex.Key, default(T));
diff --git a/src/Advanced.Algorithms/Graph/ShortestPath/Floyd-Warshall.cs b/src/Advanced.Algorithms/Graph/ShortestPath/Floyd-Warshall.cs
diff --git a/src/Advanced.Algorithms/Graph/ShortestPath/Johnsons.cs b/src/Advanced.Algorithms/Graph/ShortestPath/Johnsons.cs
diff --git a/src/Advanced.Algorithms/Graph/Sort/DepthFirstTopSort.cs b/src/Advanced.Algorithms/Graph/Sort/DepthFirstTopSort.cs
diff --git a/src/Advanced.Algorithms/Graph/Sort/KahnTopSort.cs b/src/Advanced.Algorithms/Graph/Sort/KahnTopSort.cs

Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ namespace Advanced.Algorithms.DataStructures.Graph.AdjacencyList`
`9`	`9`	`/// A directed graph implementation.`
`10`	`10`	`/// IEnumerable enumerates all vertices.`
`11`	`11`	`/// </summary>`
`12`		`- public class DiGraph<T> : IDiGraph<T>`
	`12`	`+ public class DiGraph<T> : IGraph<T>, IDiGraph<T>, IEnumerable<T>`
`13`	`13`	`{`
`14`	`14`	`public int VerticesCount => Vertices.Count;`
`15`	`15`	`internal Dictionary<T, DiGraphVertex<T>> Vertices { get; set; }`
`@@ -42,7 +42,9 @@ public DiGraphVertex<T> ReferenceVertex`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`IDiGraphVertex<T> IDiGraph<T>.ReferenceVertex => ReferenceVertex;`
`45`		`-`
	`45`	`+ IGraphVertex<T> IGraph<T>.ReferenceVertex => ReferenceVertex;`
	`46`	`+`
	`47`	`+`
`46`	`48`	`/// <summary>`
`47`	`49`	`/// Add a new vertex to this graph.`
`48`	`50`	`/// Time complexity: O(1).`
`@@ -218,28 +220,40 @@ public IDiGraphVertex<T> GetVertex(T value)`
`218`	`220`	`return Vertices[value];`
`219`	`221`	`}`
`220`	`222`
	`223`	`+ IGraphVertex<T> IGraph<T>.GetVertex(T key)`
	`224`	`+ {`
	`225`	`+ return Vertices[key];`
	`226`	`+ }`
	`227`	`+`
`221`	`228`	`IDiGraph<T> IDiGraph<T>.Clone()`
`222`	`229`	`{`
`223`	`230`	`return Clone();`
`224`	`231`	`}`
`225`	`232`
`226`		`- IEnumerator<IDiGraphVertex<T>> IEnumerable<IDiGraphVertex<T>>.GetEnumerator()`
	`233`	`+ IGraph<T> IGraph<T>.Clone()`
`227`	`234`	`{`
`228`		`- return GetEnumerator() as IEnumerator<IDiGraphVertex<T>>;`
	`235`	`+ return Clone();`
`229`	`236`	`}`
`230`	`237`
`231`	`238`	`public IEnumerator GetEnumerator()`
`232`	`239`	`{`
`233`		`- return Vertices.Select(x => x.Value).GetEnumerator();`
	`240`	`+ return Vertices.Select(x => x.Key).GetEnumerator();`
`234`	`241`	`}`
`235`	`242`
	`243`	`+ IEnumerator<T> IEnumerable<T>.GetEnumerator()`
	`244`	`+ {`
	`245`	`+ return GetEnumerator() as IEnumerator<T>;`
	`246`	`+ }`
	`247`	`+`
	`248`	`+ public IEnumerable<IGraphVertex<T>> VerticesAsEnumberable => Vertices.Select(x => x.Value);`
	`249`	`+ IEnumerable<IDiGraphVertex<T>> IDiGraph<T>.VerticesAsEnumberable => Vertices.Select(x => x.Value);`
`236`	`250`	`}`
`237`	`251`
`238`	`252`	`/// <summary>`
`239`	`253`	`/// DiGraph vertex for adjacency list Graph implementation.`
`240`	`254`	`/// IEnumerable enumerates all the outgoing edge destination vertices.`
`241`	`255`	`/// </summary>`
`242`		`- public class DiGraphVertex<T> : IDiGraphVertex<T>, IEnumerable<T>`
	`256`	`+ public class DiGraphVertex<T> : IDiGraphVertex<T>, IGraphVertex<T>, IEnumerable<T>`
`243`	`257`	`{`
`244`	`258`	`public T Key { get; set; }`
`245`	`259`
`@@ -252,6 +266,8 @@ public class DiGraphVertex<T> : IDiGraphVertex<T>, IEnumerable<T>`
`252`	`266`	`public int OutEdgeCount => OutEdges.Count;`
`253`	`267`	`public int InEdgeCount => InEdges.Count;`
`254`	`268`
	`269`	`+ IEnumerable<IEdge<T>> IGraphVertex<T>.Edges => OutEdges.Select(x => new Edge<T, int>(x, 1));`
	`270`	`+`
`255`	`271`	`public DiGraphVertex(T value)`
`256`	`272`	`{`
`257`	`273`	`Key = value;`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ namespace Advanced.Algorithms.DataStructures.Graph.AdjacencyList`
`9`	`9`	`/// A graph implementation`
`10`	`10`	`/// IEnumerable enumerates all vertices.`
`11`	`11`	`/// </summary>`
`12`		`- public class Graph<T> : IGraph<T>`
	`12`	`+ public class Graph<T> : IGraph<T>, IEnumerable<T>`
`13`	`13`	`{`
`14`	`14`	`public int VerticesCount => Vertices.Count;`
`15`	`15`	`internal Dictionary<T, GraphVertex<T>> Vertices { get; set; }`
`@@ -210,20 +210,22 @@ public Graph<T> Clone()`
`210`	`210`	`return newGraph;`
`211`	`211`	`}`
`212`	`212`
`213`		`- IEnumerator<IGraphVertex<T>> IEnumerable<IGraphVertex<T>>.GetEnumerator()`
	`213`	`+ public IEnumerator GetEnumerator()`
`214`	`214`	`{`
`215`		`- return GetEnumerator() as IEnumerator<IGraphVertex<T>>;`
	`215`	`+ return Vertices.Select(x => x.Key).GetEnumerator();`
`216`	`216`	`}`
`217`	`217`
`218`		`- public IEnumerator GetEnumerator()`
	`218`	`+ IEnumerator<T> IEnumerable<T>.GetEnumerator()`
`219`	`219`	`{`
`220`		`- return Vertices.Select(x => x.Value).GetEnumerator();`
	`220`	`+ return GetEnumerator() as IEnumerator<T>;`
`221`	`221`	`}`
`222`	`222`
`223`	`223`	`IGraph<T> IGraph<T>.Clone()`
`224`	`224`	`{`
`225`	`225`	`return Clone();`
`226`	`226`	`}`
	`227`	`+`
	`228`	`+ public IEnumerable<IGraphVertex<T>> VerticesAsEnumberable => Vertices.Select(x => x.Value);`
`227`	`229`	`}`
`228`	`230`
`229`	`231`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ namespace Advanced.Algorithms.DataStructures.Graph.AdjacencyList`
`9`	`9`	`/// A weighted graph implementation.`
`10`	`10`	`/// IEnumerable enumerates all vertices.`
`11`	`11`	`/// </summary>`
`12`		`- public class WeightedDiGraph<T, TW> : IDiGraph<T> where TW : IComparable`
	`12`	`+ public class WeightedDiGraph<T, TW> : IDiGraph<T>, IGraph<T>, IEnumerable<T> where TW : IComparable`
`13`	`13`	`{`
`14`	`14`	`public int VerticesCount => Vertices.Count;`
`15`	`15`	`internal Dictionary<T, WeightedDiGraphVertex<T, TW>> Vertices { get; set; }`
`@@ -41,6 +41,7 @@ public WeightedDiGraphVertex<T, TW> ReferenceVertex`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`IDiGraphVertex<T> IDiGraph<T>.ReferenceVertex => ReferenceVertex;`
	`44`	`+ IGraphVertex<T> IGraph<T>.ReferenceVertex => ReferenceVertex;`
`44`	`45`
`45`	`46`	`/// <summary>`
`46`	`47`	`/// Add a new vertex to this graph.`
`@@ -197,9 +198,14 @@ public bool ContainsVertex(T value)`
`197`	`198`	`return Vertices.ContainsKey(value);`
`198`	`199`	`}`
`199`	`200`
`200`		`- public IDiGraphVertex<T> GetVertex(T value)`
	`201`	`+ IGraphVertex<T> IGraph<T>.GetVertex(T key)`
`201`	`202`	`{`
`202`		`- return Vertices[value];`
	`203`	`+ return Vertices[key];`
	`204`	`+ }`
	`205`	`+`
	`206`	`+ public IDiGraphVertex<T> GetVertex(T key)`
	`207`	`+ {`
	`208`	`+ return Vertices[key];`
`203`	`209`	`}`
`204`	`210`
`205`	`211`	`/// <summary>`
`@@ -225,27 +231,35 @@ public WeightedDiGraph<T, TW> Clone()`
`225`	`231`	`return newGraph;`
`226`	`232`	`}`
`227`	`233`
`228`		`- IEnumerator<IDiGraphVertex<T>> IEnumerable<IDiGraphVertex<T>>.GetEnumerator()`
	`234`	`+ IDiGraph<T> IDiGraph<T>.Clone()`
`229`	`235`	`{`
`230`		`- return GetEnumerator() as IEnumerator<IDiGraphVertex<T>>;`
	`236`	`+ return Clone();`
	`237`	`+ }`
	`238`	`+`
	`239`	`+ IGraph<T> IGraph<T>.Clone()`
	`240`	`+ {`
	`241`	`+ return Clone();`
`231`	`242`	`}`
`232`	`243`
`233`	`244`	`public IEnumerator GetEnumerator()`
`234`	`245`	`{`
`235`		`- return Vertices.Select(x => x.Value).GetEnumerator();`
	`246`	`+ return Vertices.Select(x => x.Key).GetEnumerator();`
`236`	`247`	`}`
`237`	`248`
`238`		`- IDiGraph<T> IDiGraph<T>.Clone()`
	`249`	`+ IEnumerator<T> IEnumerable<T>.GetEnumerator()`
`239`	`250`	`{`
`240`		`- return Clone();`
	`251`	`+ return GetEnumerator() as IEnumerator<T>;`
`241`	`252`	`}`
	`253`	`+`
	`254`	`+ public IEnumerable<IGraphVertex<T>> VerticesAsEnumberable => Vertices.Select(x => x.Value);`
	`255`	`+ IEnumerable<IDiGraphVertex<T>> IDiGraph<T>.VerticesAsEnumberable => Vertices.Select(x => x.Value);`
`242`	`256`	`}`
`243`	`257`
`244`	`258`	`/// <summary>`
`245`	`259`	`/// A weighted graph vertex for adjacency list Graph implementation.`
`246`	`260`	`/// IEnumerable enumerates all the outgoing edge destination vertices.`
`247`	`261`	`/// </summary>`
`248`		`- public class WeightedDiGraphVertex<T, TW> : IDiGraphVertex<T>, IEnumerable<T> where TW : IComparable`
	`262`	`+ public class WeightedDiGraphVertex<T, TW> : IDiGraphVertex<T>, IGraphVertex<T>, IEnumerable<T> where TW : IComparable`
`249`	`263`	`{`
`250`	`264`	`public T Key { get; private set; }`
`251`	`265`
`@@ -258,6 +272,8 @@ public class WeightedDiGraphVertex<T, TW> : IDiGraphVertex<T>, IEnumerable<T> wh`
`258`	`272`	`public int OutEdgeCount => OutEdges.Count;`
`259`	`273`	`public int InEdgeCount => InEdges.Count;`
`260`	`274`
	`275`	`+ IEnumerable<IEdge<T>> IGraphVertex<T>.Edges => OutEdges.Select(x => new Edge<T, TW>(x.Key, x.Value));`
	`276`	`+`
`261`	`277`	`public WeightedDiGraphVertex(T value)`
`262`	`278`	`{`
`263`	`279`	`Key = value;`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ public List<List<T>>`
`19`	`19`	`var finishStack = new Stack<T>();`
`20`	`20`
`21`	`21`	`//step one - create DFS finish visit stack`
`22`		`- foreach (var vertex in graph)`
	`22`	`+ foreach (var vertex in graph.VerticesAsEnumberable)`
`23`	`23`	`{`
`24`	`24`	`if(!visited.Contains(vertex.Key))`
`25`	`25`	`{`
`@@ -98,12 +98,12 @@ private IDiGraph<T> reverseEdges(IDiGraph<T> graph)`
`98`	`98`	`{`
`99`	`99`	`var newGraph = new DiGraph<T>();`
`100`	`100`
`101`		`- foreach (var vertex in graph)`
	`101`	`+ foreach (var vertex in graph.VerticesAsEnumberable)`
`102`	`102`	`{`
`103`	`103`	`newGraph.AddVertex(vertex.Key);`
`104`	`104`	`}`
`105`	`105`
`106`		`- foreach (var vertex in graph)`
	`106`	`+ foreach (var vertex in graph.VerticesAsEnumberable)`
`107`	`107`	`{`
`108`	`108`	`foreach (var edge in vertex.OutEdges)`
`109`	`109`	`{`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ public List<List<T>> FindStronglyConnectedComponents(IDiGraph<T> graph)`
`22`	`22`	`var pathStack = new Stack<T>();`
`23`	`23`	`var pathStackMap = new HashSet<T>();`
`24`	`24`	`var discoveryTime = 0;`
`25`		`- foreach (var vertex in graph)`
	`25`	`+ foreach (var vertex in graph.VerticesAsEnumberable)`
`26`	`26`	`{`
`27`	`27`	`if (!discoveryTimeMap.ContainsKey(vertex.Key))`
`28`	`28`	`{`
Original file line number	Diff line number	Diff line change
`@@ -228,13 +228,13 @@ private WeightedDiGraph<T, W> createResidualGraph(IDiGraph<T> graph)`
`228`	`228`	`var newGraph = new WeightedDiGraph<T, W>();`
`229`	`229`
`230`	`230`	`//clone graph vertices`
`231`		`- foreach (var vertex in graph)`
	`231`	`+ foreach (var vertex in graph.VerticesAsEnumberable)`
`232`	`232`	`{`
`233`	`233`	`newGraph.AddVertex(vertex.Key);`
`234`	`234`	`}`
`235`	`235`
`236`	`236`	`//clone edges`
`237`		`- foreach (var vertex in graph)`
	`237`	`+ foreach (var vertex in graph.VerticesAsEnumberable)`
`238`	`238`	`{`
`239`	`239`	`//Use either OutEdges or InEdges for cloning`
`240`	`240`	`//here we use OutEdges`
Original file line number	Diff line number	Diff line change
`@@ -207,13 +207,13 @@ private WeightedDiGraph<T, W> createResidualGraph(IDiGraph<T> graph)`
`207`	`207`	`var newGraph = new WeightedDiGraph<T, W>();`
`208`	`208`
`209`	`209`	`//clone graph vertices`
`210`		`- foreach (var vertex in graph)`
	`210`	`+ foreach (var vertex in graph.VerticesAsEnumberable)`
`211`	`211`	`{`
`212`	`212`	`newGraph.AddVertex(vertex.Key);`
`213`	`213`	`}`
`214`	`214`
`215`	`215`	`//clone edges`
`216`		`- foreach (var vertex in graph)`
	`216`	`+ foreach (var vertex in graph.VerticesAsEnumberable)`
`217`	`217`	`{`
`218`	`218`	`//Use either OutEdges or InEdges for cloning`
`219`	`219`	`//here we use OutEdges`