Added Dijkstra and Bellman Ford Shortest Path Algorithms.

Author: prince776

DataStructures/Graphs/bellman_ford_shortest_path_algo.cpp

@@ -0,0 +1,116 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+#define INF 1e9 + 5
+
+struct Edge
+{
+	int src, dest, weight;
+	Edge()
+	{
+
+	}
+	Edge(int src, int dest, int weight) :
+		src(src), dest(dest), weight(weight)
+	{
+		// Nothing to do here.		
+	}
+};
+
+struct Graph
+{
+	int V, E;
+	Edge* edges;
+	Graph(int V, int E) : V(V), E(E)
+	{
+		edges = new Edge[E];
+	}
+	~Graph()
+	{
+		delete[] edges;
+	}
+};
+
+void printArr(int distTo[], int n)
+{
+	cout << "Vertex distancesfrom source: \n";
+	for (int i = 0; i < n; i++)
+		cout << i << " " << distTo[i] << "\n";
+}
+
+void BellmanFord(Graph* graph, int src)
+{
+	int V = graph->V;
+	int E = graph->E;
+	int distTo[V];
+
+	// Initialize all distances to infinity and the src to be 0.
+	for (int i = 0; i < V; i++)
+		distTo[i] = INF;
+	distTo[src] = 0;
+
+	// Relax all edges V - 1 times.
+	for (int i = 0; i < V - 1; i++)
+	{
+		for (int j = 0; j < E; j++)
+		{
+			int u = graph->edges[j].src;
+			int v = graph->edges[j].dest;
+			int weight = graph->edges[j].weight;
+			distTo[v] = min(distTo[v], distTo[u] + weight);
+		}
+	}
+	printArr(distTo, V);
+}
+
+int main()
+{
+
+	int V = 5;
+	int E = 8;
+	Graph* graph = new Graph(5, 8);
+
+// add edge 0-1 (or A-B in above figure) 
+    graph->edges[0].src = 0; 
+    graph->edges[0].dest = 1; 
+    graph->edges[0].weight = -1; 
+  
+    // add edge 0-2 (or A-C in above figure) 
+    graph->edges[1].src = 0; 
+    graph->edges[1].dest = 2; 
+    graph->edges[1].weight = 4; 
+  
+    // add edge 1-2 (or B-C in above figure) 
+    graph->edges[2].src = 1; 
+    graph->edges[2].dest = 2; 
+    graph->edges[2].weight = 3; 
+  
+    // add edge 1-3 (or B-D in above figure) 
+    graph->edges[3].src = 1; 
+    graph->edges[3].dest = 3; 
+    graph->edges[3].weight = 2; 
+  
+    // add edge 1-4 (or A-E in above figure) 
+    graph->edges[4].src = 1; 
+    graph->edges[4].dest = 4; 
+    graph->edges[4].weight = 2; 
+  
+    // add edge 3-2 (or D-C in above figure) 
+    graph->edges[5].src = 3; 
+    graph->edges[5].dest = 2; 
+    graph->edges[5].weight = 5; 
+  
+    // add edge 3-1 (or D-B in above figure) 
+    graph->edges[6].src = 3; 
+    graph->edges[6].dest = 1; 
+    graph->edges[6].weight = 1; 
+  
+    // add edge 4-3 (or E-D in above figure) 
+    graph->edges[7].src = 4; 
+    graph->edges[7].dest = 3; 
+    graph->edges[7].weight = -3; 
+
+    BellmanFord(graph, 0);
+
+    return 0;
+}

DataStructures/Graphs/dijkstra_shortest_path_algorithm.cpp

@@ -0,0 +1,97 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+#define INF 1e9 + 5
+
+struct Graph
+{
+	int V;
+	vector<pair<int, int>> *adjList;
+	Graph(int V) : V(V)
+	{
+		adjList = new vector<pair<int, int>>[V];
+	}
+	~Graph()
+	{
+		delete[] adjList;
+	}
+	void addEdge(int src, int dest, int weight);
+};
+
+
+void Graph::addEdge(int src, int dest, int weight)
+{
+	adjList[src].push_back(make_pair(dest, weight));
+}
+
+struct comparer
+{
+	bool operator()(pair<int, int> a, pair<int, int> b)
+	{
+		return a.second < b.second;
+	}	
+};
+
+void DijkstraSP(Graph *graph, int src)
+{
+	int V = graph->V;
+	
+	int distTo[V];
+	bool processed[V];
+
+
+	for (int i = 0; i < V; i++)
+	{	
+		distTo[i] = INF;
+		processed[i] = false;
+	}
+	distTo[src] = 0;
+	priority_queue<pair<int, int>, vector<pair<int, int>>, comparer> pq;
+	pq.push(make_pair(src, 0));
+	while (!pq.empty())
+	{
+		int a = pq.top().first;
+		pq.pop();
+		if (processed[a]) continue;
+		processed[a] = true;
+		for (auto &it : graph->adjList[a])
+		{
+			int b = it.first;
+			int w = it.second;
+			if (distTo[b] > distTo[a] + w)
+			{
+				distTo[b] = distTo[a] + w;
+				pq.push(make_pair(b, distTo[b]));
+			}
+		}
+	}
+
+	cout << "Vertex distancesfrom source: \n";
+	for (int i = 0; i < V; i++)
+		cout << i << " " << distTo[i] << "\n";
+}
+
+int main()
+{
+	int V = 9;
+	Graph *graph = new Graph(V);
+
+	graph->addEdge(0, 1, 4);
+	graph->addEdge(0, 7, 8);
+	graph->addEdge(1, 2, 8);
+	graph->addEdge(1, 7, 11);
+	graph->addEdge(2, 3, 7);
+	graph->addEdge(2, 8, 2);
+	graph->addEdge(2, 5, 4);
+	graph->addEdge(3, 4, 9);
+	graph->addEdge(3, 5, 14);
+	graph->addEdge(4, 5, 10);
+	graph->addEdge(5, 6, 2);
+	graph->addEdge(6, 7, 1);
+	graph->addEdge(6, 8, 6);
+	graph->addEdge(7, 8, 7);
+
+	DijkstraSP(graph, 0);
+
+	return 0;
+}