added the bellman ford shortest path thinking to add more of the graphs problems as its likee too emty in the folder

Author: pranavkhapra

graphs/BellmanFordShortestPaths.cs

@@ -0,0 +1,259 @@
+using System;
+using System.Diagnostics;
+using System.Collections.Generic;
+using Algorithms.Common;
+using DataStructures.Graphs;
+
+namespace Algorithms.Graphs
+{
+ public class BellmanFordShortestPaths<TGraph, TVertex>
+ where TGraph : IGraph<TVertex>, IWeightedGraph<TVertex>
+ where TVertex : IComparable<TVertex>
+ {
+ /// INSTANCE VARIABLES
+ private int _edgesCount;
+ private int _verticesCount;
+ private long[] _distances;
+ private int[] _predecessors;
+ private WeightedEdge<TVertex>[] _edgeTo;
+
+ // A dictionary that maps node-values to integer indeces
+ private Dictionary<TVertex, int> _nodesToIndices;
+
+ // A dictionary that maps integer index to node-value
+ private Dictionary<int, TVertex> _indicesToNodes;
+
+ // A const that represent an infinite distance
+ private const Int64 Infinity = Int64.MaxValue;
+ private const int NilPredecessor = -1;
+
+
+ /// CONSTRUCTOR
+ public BellmanFordShortestPaths(TGraph Graph, TVertex Source)
+ {
+ if (Graph == null) {
+ throw new ArgumentNullException ();
+ } else {
+ if (!Graph.HasVertex (Source))
+ throw new ArgumentException ("The source vertex doesn't belong to graph.");
+
+ // Init
+ _initializeDataMembers (Graph);
+
+ // Traverse the graph
+ var status = _bellmanFord (Graph, Source);
+
+ if (status == false)
+ throw new Exception ("Negative-weight cycle detected.");
+
+ Debug.Assert (_checkOptimalityConditions (Graph, Source));
+ }
+ }
+
+
+ /************************************************************************************************************/
+
+
+ /// The Bellman-Ford Algorithm.
+ /// <>True if shortest-path computation is finished with no negative-weight cycles detected; otehrwise, false.</>
+ private bool _bellmanFord(TGraph graph, TVertex source)
+ {
+ int srcIndex = _nodesToIndices[source];
+ _distances[srcIndex] = 0;
+
+ var edges = graph.Edges as IEnumerable<WeightedEdge<TVertex>>;
+
+ // First pass
+ // Calculate shortest paths and relax all edges.
+ for (int i = 1; i < graph.VerticesCount - 1; ++i)
+ {
+ foreach (var edge in edges)
+ {
+ int fromIndex = _nodesToIndices[edge.Source];
+ int toIndex = _nodesToIndices[edge.Destination];
+
+ // calculate a new possible weighted path if the edge weight is less than infinity
+ var delta = Infinity;
+ if (edge.Weight < Infinity && (Infinity - edge.Weight) > _distances[fromIndex]) // Handles overflow
+ delta = _distances[fromIndex] + edge.Weight;
+
+ // Relax the edge
+ // if check is true, a shorter path is found from current to adjacent
+ if (delta < _distances[toIndex])
+ {
+ _edgeTo[toIndex] = edge;
+ _distances[toIndex] = delta;
+ _predecessors[toIndex] = fromIndex;
+ }
+ }
+ }
+
+ // Second pass
+ // Check for negative-weight cycles.
+ foreach (var edge in edges)
+ {
+ int fromIndex = _nodesToIndices[edge.Source];
+ int toIndex = _nodesToIndices[edge.Destination];
+
+ // calculate a new possible weighted path if the edge weight is less than infinity
+ var delta = Infinity;
+ if (edge.Weight < Infinity && (Infinity - edge.Weight) > _distances[fromIndex]) // Handles overflow
+ delta = _distances[fromIndex] + edge.Weight;
+
+ // if check is true a negative-weight cycle is detected
+ // return false;
+ if (delta < _distances[toIndex])
+ return false;
+ }
+
+ // Completed shortest paths computation.
+ // No negative edges were detected.
+ return true;
+ }
+
+ /// Constructors helper function. Initializes some of the data memebers.
+ private void _initializeDataMembers(TGraph Graph)
+ {
+ _edgesCount = Graph.EdgesCount;
+ _verticesCount = Graph.VerticesCount;
+
+ _distances = new Int64[_verticesCount];
+ _predecessors = new int[_verticesCount];
+ _edgeTo = new WeightedEdge<TVertex>[_edgesCount];
+
+ _nodesToIndices = new Dictionary<TVertex, int>();
+ _indicesToNodes = new Dictionary<int, TVertex>();
+
+ // Reset the information arrays
+ int i = 0;
+ foreach (var node in Graph.Vertices)
+ {
+ if (i >= _verticesCount)
+ break;
+
+ _edgeTo[i] = null;
+ _distances[i] = Infinity;
+ _predecessors[i] = NilPredecessor;
+
+ _nodesToIndices.Add(node, i);
+ _indicesToNodes.Add(i, node);
+
+ ++i;
+ }
+ }
+
+ /// Constructors helper function. Checks Optimality Conditions:
+ /// (i) for all edges e: distTo[e.to()] <= distTo[e.from()] + e.weight()
+ /// (ii) for all edge e on the SPT: distTo[e.to()] == distTo[e.from()] + e.weight()
+ private bool _checkOptimalityConditions(TGraph graph, TVertex source)
+ {
+ // Get the source index (to be used with the information arrays).
+ int s = _nodesToIndices[source];
+
+ // check that distTo[v] and edgeTo[v] are consistent
+ if (_distances[s] != 0 || _predecessors[s] != NilPredecessor)
+ {
+ Console.WriteLine("distanceTo[s] and edgeTo[s] are inconsistent");
+ return false;
+ }
+
+ for (int v = 0; v < graph.VerticesCount; v++)
+ {
+ if (v == s) continue;
+
+ if (_predecessors[v] == NilPredecessor && _distances[v] != Infinity)
+ {
+ Console.WriteLine("distanceTo[] and edgeTo[] are inconsistent for at least one vertex.");
+ return false;
+ }
+ }
+
+ // check that all edges e = v->w satisfy distTo[w] <= distTo[v] + e.weight()
+ foreach (var vertex in graph.Vertices)
+ {
+ int v = _nodesToIndices[vertex];
+
+ foreach (var edge in graph.NeighboursMap(vertex))
+ {
+ int w = _nodesToIndices[edge.Key];
+
+ if (_distances[v] + edge.Value < _distances[w])
+ {
+ Console.WriteLine("edge " + vertex + "-" + edge.Key + " is not relaxed");
+ return false;
+ }
+ }
+ }
+
+ // check that all edges e = v->w on SPT satisfy distTo[w] == distTo[v] + e.weight()
+ foreach (var vertex in graph.Vertices)
+ {
+ int w = _nodesToIndices[vertex];
+
+ if (_edgeTo[w] == null)
+ continue;
+
+ var edge = _edgeTo[w];
+ int v = _nodesToIndices[edge.Source];
+
+ if (!vertex.IsEqualTo(edge.Destination))
+ return false;
+
+ if ((_distances[v] + edge.Weight) != _distances[w])
+ {
+ Console.WriteLine("edge " + edge.Source + "-" + edge.Destination + " on shortest path not tight");
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+
+ /************************************************************************************************************/
+
+
+ /// Determines whether there is a path from the source vertex to this specified vertex.
+ public bool HasPathTo(TVertex destination)
+ {
+ if (!_nodesToIndices.ContainsKey(destination))
+ throw new Exception("Graph doesn't have the specified vertex.");
+
+ int index = _nodesToIndices[destination];
+ return _distances[index] != Infinity;
+ }
+
+ /// Returns the distance between the source vertex and the specified vertex.
+ public long DistanceTo(TVertex destination)
+ {
+ if (!_nodesToIndices.ContainsKey(destination))
+ throw new Exception("Graph doesn't have the specified vertex.");
+
+ int index = _nodesToIndices[destination];
+ return _distances[index];
+ }
+
+ /// Returns an enumerable collection of nodes that specify the shortest path from the source vertex to the destination vertex.
+ public IEnumerable<TVertex> ShortestPathTo(TVertex destination)
+ {
+ if (!_nodesToIndices.ContainsKey(destination))
+ throw new Exception("Graph doesn't have the specified vertex.");
+ if (!HasPathTo(destination))
+ return null;
+
+ int dstIndex = _nodesToIndices[destination];
+ var stack = new DataStructures.Lists.Stack<TVertex>();
+
+ int index;
+ for (index = dstIndex; _distances[index] != 0; index = _predecessors[index])
+ stack.Push(_indicesToNodes[index]);
+
+ // Push the source vertex
+ stack.Push(_indicesToNodes[index]);
+
+ return stack;
+ }
+
+ }
+
+}