Addition of C++ code for Floyd Warshall

FloydWarshall.cpp

@@ -0,0 +1,62 @@
+//Constructed in C++14
+#include <iostream>
+#define INF 1000000007 //Consider that this is the maximum possible cost you can have
+using namespace std;
+int main()
+{
+	int nodes,edges;
+
+	cout<<"Enter the total number of nodes: ";
+	cin>>nodes; //Enter the number of nodes
+
+	cout<<"Enter the total number of edges: ";
+	cin>>edges; //Enter the number of edges
+
+	int dist[nodes+1][nodes+1]; //Declaration of a dist as adjoint matrix representation
+
+	for(int i=0;i<=nodes;i++)
+		for(int j=0;j<=nodes;j++)
+			dist[i][j]=INF; //Initialising distance cost to infinity
+
+	cout<<"Enter the edges in this format: <node1> <space> <node2> <space> <cost>"<<endl;
+	//Please follow the input format and remember nodes are numbered from "1" to the input value "nodes"
+
+	for(int i=0;i<edges;i++)
+	{
+		int x,y,z;
+		cin>>x>>y>>z;
+		dist[x][y]=z; //Assigning the input values
+	}
+
+	//The main algorithm begins here
+
+	for(int k=1;k<=nodes;k++)  
+    {  
+        // Pick all nodes as source one by one  
+        for(int i=1;i<=nodes;i++)  
+        {  
+            // Pick all nodes as destination for the above picked source  
+            for(int j=1;j<=nodes;j++)  
+            {  
+                // If node k is on the shortest path from i to j, then update the value of dist[i][j]  
+                if (dist[i][k] + dist[k][j] < dist[i][j])  
+                    dist[i][j] = dist[i][k] + dist[k][j];  
+            }  
+        }  
+    }
+
+    //Now we print the respective all pairs' shortest path distances
+    cout<<endl<<"The following matrix shows the shortest distances between every pair of nodes"<<endl;  
+    for(int i=1;i<=nodes;i++)  
+    {  
+        for(int j=1;j<=nodes;j++)  
+        {  
+            if (dist[i][j]==INF)  
+                cout<<j<<" can never be reached from "<<i<<endl;  
+            else
+                cout<<"Distance from "<<i<<" to "<<j<<" is "<<dist[i][j]<<endl;  
+        }
+    }  
+
+    return 0;
+}

Prim.cpp

@@ -0,0 +1,89 @@
+#include <limits.h> 
+#include <stdbool.h> 
+#include <stdio.h>  
+#define V 5 
+
+// A utility function to find the vertex with 
+// minimum key value, from the set of vertices 
+// not yet included in MST 
+int minKey(int key[], bool mstSet[]) 
+{ 
+    // Initialize min value 
+    int min = INT_MAX, min_index; 
+
+    for (int v = 0; v < V; v++) 
+        if (mstSet[v] == false && key[v] < min) 
+            min = key[v], min_index = v; 
+
+    return min_index; 
+} 
+
+int printMST(int parent[], int graph[V][V]) 
+{ 
+    printf("Edge \tWeight\n"); 
+    for (int i = 1; i < V; i++) 
+        printf("%d - %d \t%d \n", parent[i], i, graph[i][parent[i]]); 
+} 
+
+// Function to construct and print MST for 
+// a graph represented using adjacency 
+// matrix representation 
+void primMST(int graph[V][V]) 
+{ 
+    // Array to store constructed MST 
+    int parent[V]; 
+    // Key values used to pick minimum weight edge in cut 
+    int key[V]; 
+    // To represent set of vertices not yet included in MST 
+    bool mstSet[V]; 
+
+    // Initialize all keys as INFINITE 
+    for (int i = 0; i < V; i++) 
+        key[i] = INT_MAX, mstSet[i] = false; 
+
+    // Always include first 1st vertex in MST. 
+    // Make key 0 so that this vertex is picked as first vertex. 
+    key[0] = 0; 
+    parent[0] = -1; // First node is always root of MST 
+
+    // The MST will have V vertices 
+    for (int count = 0; count < V - 1; count++) { 
+        // Pick the minimum key vertex from the 
+        // set of vertices not yet included in MST 
+        int u = minKey(key, mstSet); 
+
+        // Add the picked vertex to the MST Set 
+        mstSet[u] = true; 
+
+        // Update key value and parent index of 
+        // the adjacent vertices of the picked vertex. 
+        // Consider only those vertices which are not 
+        // yet included in MST 
+        for (int v = 0; v < V; v++) 
+
+            // graph[u][v] is non zero only for adjacent vertices of m 
+            // mstSet[v] is false for vertices not yet included in MST 
+            // Update the key only if graph[u][v] is smaller than key[v] 
+            if (graph[u][v] && mstSet[v] == false && graph[u][v] < key[v]) 
+                parent[v] = u, key[v] = graph[u][v]; 
+    } 
+
+    // print the constructed MST 
+    printMST(parent, graph); 
+} 
+
+// to test  
+int main() 
+{ 
+    /* Let us create the following graph */
+    int graph[V][V] = { { 0, 2, 0, 6, 0 }, 
+                        { 2, 0, 3, 8, 5 }, 
+                        { 0, 3, 0, 0, 7 }, 
+                        { 6, 8, 0, 0, 9 }, 
+                        { 0, 5, 7, 9, 0 } }; 
+
+
+    primMST(graph); 
+
+    return 0; 
+}