mirror of
https://github.com/TheAlgorithms/C-Plus-Plus.git
synced 2026-06-30 17:16:30 +08:00
151 lines
3.3 KiB
C++
151 lines
3.3 KiB
C++
/*
|
||
*
|
||
*
|
||
*
|
||
*
|
||
*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
|
||
*/
|
||
|
||
|