diff --git a/graph/Johnson's algorithm.cpp b/graph/Johnson's algorithm.cpp
new file mode 100644
index 000000000..bab322c0a
--- /dev/null
+++ b/graph/Johnson's algorithm.cpp	
@@ -0,0 +1,150 @@
+/*
+*
+*
+*
+*
+*brief-- Johnson's algorithm*
+*
+*Details-
+*finding shortest paths between
+*every pair of vertices in a given
+*weighted directed Graph and weights may be negative.
+*
+*
+*
+*
+*---Complexity----
+*O(V^2logV + V*E)
+*
+*
+*
+*---Application-----
+*
+*
+*
+*1.A new vertex is added to the graph, and it is connected by edges of zero weight to all other vertices in the graph.
+*2.All edges go through a reweighting process that eliminates negative weight edges.
+*3.The added vertex from step 1 is removed and Dijkstra's algorithm is run on every node in the graph.
+*
+*
+*
+*
+*------Algorithm Idea-----
+*
+*1. Let the given graph be G.
+Add a new vertex s to the graph,
+add edges from new vertex to all vertices of G.
+Let the modified graph be G’.
+*
+*
+*2.Run Bellman-Ford algorithm on G’ with s as source.
+Let the distances calculated by Bellman-Ford be h[0], h[1], .. h[V-1].
+If we find a negative weight cycle, then return.
+Note that the negative weight cycle cannot be created by new vertex s as there is no edge to s.
+All edges are from s.
+*
+*
+*3.Reweight the edges of original graph.
+For each edge (u, v), assign the new weight as “original weight + h[u] – h[v]”.
+*
+*
+*4.Remove the added vertex s and run Dijkstra’s algorithm for every vertex.
+*
+*
+*/
+
+/**
+*
+*
+*-----Pseudo Code------
+* 1.
+    create G` where G`.V = G.V + {s},
+        G`.E = G.E + ((s, u) for u in G.V), and
+        weight(s, u) = 0 for u in G.V
+*
+* 2.
+    if Bellman-Ford(s) == False
+        return "The input graph has a negative weight cycle"
+    else:
+        for vertex v in G`.V:
+            h(v) = distance(s, v) computed by Bellman-Ford
+        for edge (u, v) in G`.E:
+            weight`(u, v) = weight(u, v) + h(u) - h(v)
+*
+*
+*3.
+        D = new matrix of distances initialized to infinity
+        for vertex u in G.V:
+            run Dijkstra(G, weight`, u) to compute distance`(u, v) for all v in G.V
+            for each vertex v in G.V:
+                D_(u, v) = distance`(u, v) + h(v) - h(u)
+        return D
+*
+*/
+
+
+
+#include<iostream>
+#define INF 9999
+using namespace std;
+int min(int a, int b);
+
+int cost[10][10], adj[10][10]; // declaring two 2-D array
+
+inline int min(int a, int b){
+    /**Returns the minimum value*/
+   return (a<b)?a:b;
+}
+main() {
+   int vert, edge, i, j, k, c; // declaring variables
+   cout << "Enter no of vertices: ";
+   cin >> vert;
+   cout << "Enter no of edges: ";
+   cin >> edge;
+   cout << "Enter the EDGE Costs:\n";
+   for (k = 1; k <= edge; k++) {
+        /**take the input and store it into adj and cost matrix*/
+      cin >> i >> j >> c;
+      adj[i][j] = cost[i][j] = c;
+   }
+   for (i = 1; i <= vert; i++)
+      for (j = 1; j <= vert; j++) {
+         if (adj[i][j] == 0 && i != j)
+            adj[i][j] = INF;
+   /**if there is no edge, put infinity*/
+      }
+   for (k = 1; k <= vert; k++)
+      for (i = 1; i <= vert; i++)
+         for (j = 1; j <= vert; j++)
+            adj[i][j] = min(adj[i][j], adj[i][k] + adj[k][j]);
+            /**find minimum path from i to j through k*/
+   cout << "Resultant adj matrix\n";
+   for (i = 1; i <= vert; i++) {
+      for (j = 1; j <= vert; j++) {
+            if (adj[i][j] != INF)
+               cout << adj[i][j] << " ";
+      }
+      cout << "\n";
+   }
+   return 0;
+}
+
+
+/**
+-----OUTPUT--------
+
+Enter no of vertices: 3
+Enter no of edges: 5
+Enter the EDGE Costs:
+1 2 8
+2 1 12
+1 3 22
+3 1 6
+2 3 4
+Resultant adj matrix
+0 8 12
+10 0 4
+6 14 0
+*/
+
+