Related Articles
Print negative weight cycle in a Directed Graph
• Difficulty Level : Medium
• Last Updated : 29 Dec, 2020

Given a weighted directed graph consisting of V vertices and E edges. The task is to print the cyclic path whose sum of weight is negative. If there is no such path present then print “-1”

Input: V = 5, E = 5, Below is the graph:

Output: 1 2 3 4 1
Explanation:
Given graph contains a negative cycle, (1->2->3->4->1)

Input: V = 5, E = 5, Below is the graph:

Output: 0 1 2 3 4 0
Explanation:
Given graph contains a negative cycle, (0->1->2->3->4->0)

Approach: The idea is to use Bellman-Ford Algorithm which is used to detect a negative cycle or not. To print the negative cycles, perform the Nth iteration of Bellman-Ford and pick a vertex from any edge which is relaxed in this iteration. Using this vertex and its ancestors, the negative cycle can be printed. Below are the steps:

• Perform N-1 iterations of Bellman-Ford algorithm and relax each edge (u, v). Keep track of parent of each vertex and store in an array parent[].
• Now, do one more iteration and if no edge relaxation take place in this Nth iteration, then there is no cycle of negative weight exists in the graph.
• Otherwise take a variable C and store the vertex v from any edge (u, v), which is relaxed in the Nth iteration.
• Now, starting from the C vertex go towards its ancestors until a cycle is found and finally print it.
• This cycle will be the desired cycle of negative weight.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `// Structure to represent a weighted` `// edge in graph` `struct` `Edge {` `    ``int` `src, dest, weight;` `};`   `// Structure to represent a directed` `// and weighted graph` `struct` `Graph {`   `    ``// V -> Number of vertices,` `    ``// E -> Number of edges` `    ``int` `V, E;`   `    ``// Graph is represented as an` `    ``// array of edges` `    ``struct` `Edge* edge;` `};`   `// Creates a new graph with V vertices` `// and E edges` `struct` `Graph* createGraph(``int` `V, ``int` `E)` `{` `    ``struct` `Graph* graph = ``new` `Graph;` `    ``graph->V = V;` `    ``graph->E = E;` `    ``graph->edge = ``new` `Edge[graph->E];` `    ``return` `graph;` `}`   `// Function runs Bellman-Ford algorithm` `// and prints negative cycle(if present)` `void` `NegCycleBellmanFord(``struct` `Graph* graph,` `                         ``int` `src)` `{` `    ``int` `V = graph->V;` `    ``int` `E = graph->E;` `    ``int` `dist[V];` `    ``int` `parent[V];`   `    ``// Initialize distances from src` `    ``// to all other vertices as INFINITE` `    ``// and all parent as -1` `    ``for` `(``int` `i = 0; i < V; i++) {`   `        ``dist[i] = INT_MAX;` `        ``parent[i] = -1;` `    ``}` `    ``dist[src] = 0;`   `    ``// Relax all edges |V| - 1 times.` `    ``for` `(``int` `i = 1; i <= V - 1; i++) {` `        ``for` `(``int` `j = 0; j < E; j++) {`   `            ``int` `u = graph->edge[j].src;` `            ``int` `v = graph->edge[j].dest;` `            ``int` `weight = graph->edge[j].weight;`   `            ``if` `(dist[u] != INT_MAX` `                ``&& dist[u] + weight < dist[v]) {`   `                ``dist[v] = dist[u] + weight;` `                ``parent[v] = u;` `            ``}` `        ``}` `    ``}`   `    ``// Check for negative-weight cycles` `    ``int` `C = -1;` `    ``for` `(``int` `i = 0; i < E; i++) {`   `        ``int` `u = graph->edge[i].src;` `        ``int` `v = graph->edge[i].dest;` `        ``int` `weight = graph->edge[i].weight;`   `        ``if` `(dist[u] != INT_MAX` `            ``&& dist[u] + weight < dist[v]) {`   `            ``// Store one of the vertex of` `            ``// the negative weight cycle` `            ``C = v;` `            ``break``;` `        ``}` `    ``}`   `    ``if` `(C != -1) {`   `        ``for` `(``int` `i = 0; i < V; i++)` `            ``C = parent[C];`   `        ``// To store the cycle vertex` `        ``vector<``int``> cycle;` `        ``for` `(``int` `v = C;; v = parent[v]) {`   `            ``cycle.push_back(v);` `            ``if` `(v == C` `                ``&& cycle.size() > 1)` `                ``break``;` `        ``}`   `        ``// Reverse cycle[]` `        ``reverse(cycle.begin(), cycle.end());`   `        ``// Printing the negative cycle` `        ``for` `(``int` `v : cycle)` `            ``cout << v << ``' '``;` `        ``cout << endl;` `    ``}` `    ``else` `        ``cout << ``"-1"` `<< endl;` `}`   `// Driver Code` `int` `main()` `{` `    ``// Number of vertices in graph` `    ``int` `V = 5;`   `    ``// Number of edges in graph` `    ``int` `E = 5;`   `    ``struct` `Graph* graph = createGraph(V, E);`   `    ``// Given Graph` `    ``graph->edge[0].src = 0;` `    ``graph->edge[0].dest = 1;` `    ``graph->edge[0].weight = 1;`   `    ``graph->edge[1].src = 1;` `    ``graph->edge[1].dest = 2;` `    ``graph->edge[1].weight = 2;`   `    ``graph->edge[2].src = 2;` `    ``graph->edge[2].dest = 3;` `    ``graph->edge[2].weight = 3;`   `    ``graph->edge[3].src = 3;` `    ``graph->edge[3].dest = 4;` `    ``graph->edge[3].weight = -3;`   `    ``graph->edge[4].src = 4;` `    ``graph->edge[4].dest = 1;` `    ``graph->edge[4].weight = -3;`   `    ``// Function Call` `    ``NegCycleBellmanFord(graph, 0);`   `    ``return` `0;` `}`

## Java

 `// Java program for the above approach` `import` `java.util.ArrayList;` `import` `java.util.Collections;`   `class` `GFG{`   `// Structure to represent a weighted` `// edge in graph` `static` `class` `Edge ` `{` `    ``int` `src, dest, weight;` `}`   `// Structure to represent a directed` `// and weighted graph` `static` `class` `Graph` `{` `    `  `    ``// V. Number of vertices, E.` `    ``// Number of edges` `    ``int` `V, E;`   `    ``// Graph is represented as` `    ``// an array of edges.` `    ``Edge[] edge;` `}`   `// Creates a new graph with V vertices` `// and E edges` `static` `Graph createGraph(``int` `V, ``int` `E) ` `{` `    ``Graph graph = ``new` `Graph();` `    ``graph.V = V;` `    ``graph.E = E;` `    ``graph.edge = ``new` `Edge[graph.E];`   `    ``for``(``int` `i = ``0``; i < graph.E; i++)` `    ``{` `        ``graph.edge[i] = ``new` `Edge();` `    ``}`   `    ``return` `graph;` `}`   `// Function runs Bellman-Ford algorithm` `// and prints negative cycle(if present)` `static` `void` `NegCycleBellmanFord(Graph graph, ``int` `src)` `{` `    ``int` `V = graph.V;` `    ``int` `E = graph.E;` `    ``int``[] dist = ``new` `int``[V];` `    ``int``[] parent = ``new` `int``[V];`   `    ``// Initialize distances from src` `    ``// to all other vertices as INFINITE` `    ``// and all parent as -1` `    ``for``(``int` `i = ``0``; i < V; i++) ` `    ``{` `        ``dist[i] = ``1000000``;` `        ``parent[i] = -``1``;` `    ``}` `    ``dist[src] = ``0``;`   `    ``// Relax all edges |V| - 1 times.` `    ``for``(``int` `i = ``1``; i <= V - ``1``; i++)` `    ``{` `        ``for``(``int` `j = ``0``; j < E; j++)` `        ``{` `            ``int` `u = graph.edge[j].src;` `            ``int` `v = graph.edge[j].dest;` `            ``int` `weight = graph.edge[j].weight;`   `            ``if` `(dist[u] != ``1000000` `&& ` `                ``dist[u] + weight < dist[v])` `            ``{` `                ``dist[v] = dist[u] + weight;` `                ``parent[v] = u;` `            ``}` `        ``}` `    ``}`   `    ``// Check for negative-weight cycles` `    ``int` `C = -``1``;` `    ``for``(``int` `i = ``0``; i < E; i++) ` `    ``{` `        ``int` `u = graph.edge[i].src;` `        ``int` `v = graph.edge[i].dest;` `        ``int` `weight = graph.edge[i].weight;`   `        ``if` `(dist[u] != ``1000000` `&& ` `            ``dist[u] + weight < dist[v])` `        ``{` `            `  `            ``// Store one of the vertex of` `            ``// the negative weight cycle` `            ``C = v;` `            ``break``;` `        ``}` `    ``}`   `    ``if` `(C != -``1``)` `    ``{` `        ``for``(``int` `i = ``0``; i < V; i++)` `            ``C = parent[C];`   `        ``// To store the cycle vertex` `        ``ArrayList cycle = ``new` `ArrayList<>();` `        ``for``(``int` `v = C;; v = parent[v])` `        ``{` `            ``cycle.add(v);` `            `  `            ``if` `(v == C && cycle.size() > ``1``)` `                ``break``;` `        ``}`   `        ``// Reverse cycle[]` `        ``Collections.reverse(cycle);`   `        ``// Printing the negative cycle` `        ``for``(``int` `v : cycle)` `            ``System.out.print(v + ``" "``);` `            `  `        ``System.out.println();` `    ``} ` `    ``else` `        ``System.out.println(-``1``);` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    `  `    ``// Number of vertices in graph` `    ``int` `V = ``5``;`   `    ``// Number of edges in graph` `    ``int` `E = ``5``;`   `    ``Graph graph = createGraph(V, E);`   `    ``// Given Graph` `    ``graph.edge[``0``].src = ``0``;` `    ``graph.edge[``0``].dest = ``1``;` `    ``graph.edge[``0``].weight = ``1``;`   `    ``graph.edge[``1``].src = ``1``;` `    ``graph.edge[``1``].dest = ``2``;` `    ``graph.edge[``1``].weight = ``2``;`   `    ``graph.edge[``2``].src = ``2``;` `    ``graph.edge[``2``].dest = ``3``;` `    ``graph.edge[``2``].weight = ``3``;`   `    ``graph.edge[``3``].src = ``3``;` `    ``graph.edge[``3``].dest = ``4``;` `    ``graph.edge[``3``].weight = -``3``;`   `    ``graph.edge[``4``].src = ``4``;` `    ``graph.edge[``4``].dest = ``1``;` `    ``graph.edge[``4``].weight = -``3``;`   `    ``// Function Call` `    ``NegCycleBellmanFord(graph, ``0``);` `}` `}`   `// This code is contributed by sanjeev2552`

## Python3

 `# Python3 program for the above approach` ` `  `# Structure to represent a weighted` `# edge in graph` `class` `Edge:   ` `    ``def` `__init__(``self``):` `        ``self``.src ``=` `0` `        ``self``.dest ``=` `0` `        ``self``.weight ``=` `0`   `# Structure to represent a directed` `# and weighted graph` `class` `Graph:`   `    ``def` `__init__(``self``):` `        `  `        ``# V. Number of vertices, E.` `        ``# Number of edges` `        ``self``.V ``=` `0` `        ``self``.E ``=` `0` `        `  `        ``# Graph is represented as` `        ``# an array of edges.` `        ``self``.edge ``=` `[]` `     `  `# Creates a new graph with V vertices` `# and E edges` `def` `createGraph(V, E):` `    ``graph ``=` `Graph();` `    ``graph.V ``=` `V;` `    ``graph.E ``=` `E;` `    ``graph.edge ``=` `[Edge() ``for` `i ``in` `range``(graph.E)]` `    ``return` `graph;` `  `  `# Function runs Bellman-Ford algorithm` `# and prints negative cycle(if present)` `def` `NegCycleBellmanFord(graph, src):` `    ``V ``=` `graph.V;` `    ``E ``=` `graph.E;` `    ``dist ``=``[``1000000` `for` `i ``in` `range``(V)]` `    ``parent ``=``[``-``1` `for` `i ``in` `range``(V)]` `    ``dist[src] ``=` `0``;` ` `  `    ``# Relax all edges |V| - 1 times.` `    ``for` `i ``in` `range``(``1``, V):` `        ``for` `j ``in` `range``(E):` `    `  `            ``u ``=` `graph.edge[j].src;` `            ``v ``=` `graph.edge[j].dest;` `            ``weight ``=` `graph.edge[j].weight;` ` `  `            ``if` `(dist[u] !``=` `1000000` `and` `                ``dist[u] ``+` `weight < dist[v]):` `            `  `                ``dist[v] ``=` `dist[u] ``+` `weight;` `                ``parent[v] ``=` `u;` ` `  `    ``# Check for negative-weight cycles` `    ``C ``=` `-``1``;    ` `    ``for` `i ``in` `range``(E):   ` `        ``u ``=` `graph.edge[i].src;` `        ``v ``=` `graph.edge[i].dest;` `        ``weight ``=` `graph.edge[i].weight;` ` `  `        ``if` `(dist[u] !``=` `1000000` `and` `            ``dist[u] ``+` `weight < dist[v]):` `             `  `            ``# Store one of the vertex of` `            ``# the negative weight cycle` `            ``C ``=` `v;` `            ``break``;` `         `  `    ``if` `(C !``=` `-``1``):       ` `        ``for` `i ``in` `range``(V):       ` `            ``C ``=` `parent[C];` ` `  `        ``# To store the cycle vertex` `        ``cycle ``=` `[]       ` `        ``v ``=` `C` `        `  `        ``while` `(``True``):` `            ``cycle.append(v)` `            ``if` `(v ``=``=` `C ``and` `len``(cycle) > ``1``):` `                ``break``;` `            ``v ``=` `parent[v]` ` `  `        ``# Reverse cycle[]` `        ``cycle.reverse()` ` `  `        ``# Printing the negative cycle` `        ``for` `v ``in` `cycle:       ` `            ``print``(v, end ``=` `" "``);             ` `        ``print``()   ` `    ``else``:` `        ``print``(``-``1``);` ` `  `# Driver Code` `if` `__name__``=``=``'__main__'``:` `     `  `    ``# Number of vertices in graph` `    ``V ``=` `5``;` ` `  `    ``# Number of edges in graph` `    ``E ``=` `5``; ` `    ``graph ``=` `createGraph(V, E);` ` `  `    ``# Given Graph` `    ``graph.edge[``0``].src ``=` `0``;` `    ``graph.edge[``0``].dest ``=` `1``;` `    ``graph.edge[``0``].weight ``=` `1``;` ` `  `    ``graph.edge[``1``].src ``=` `1``;` `    ``graph.edge[``1``].dest ``=` `2``;` `    ``graph.edge[``1``].weight ``=` `2``;` ` `  `    ``graph.edge[``2``].src ``=` `2``;` `    ``graph.edge[``2``].dest ``=` `3``;` `    ``graph.edge[``2``].weight ``=` `3``;` ` `  `    ``graph.edge[``3``].src ``=` `3``;` `    ``graph.edge[``3``].dest ``=` `4``;` `    ``graph.edge[``3``].weight ``=` `-``3``;` ` `  `    ``graph.edge[``4``].src ``=` `4``;` `    ``graph.edge[``4``].dest ``=` `1``;` `    ``graph.edge[``4``].weight ``=` `-``3``;` ` `  `    ``# Function Call` `    ``NegCycleBellmanFord(graph, ``0``);`   `# This code is contributed by Pratham76`

## C#

 `// C# program for the above approach` `using` `System;` `using` `System.Collections;` `using` `System.Collections.Generic;`   `class` `GFG {`   `    ``// Structure to represent a weighted` `    ``// edge in graph` `    ``class` `Edge {` `        ``public` `int` `src, dest, weight;` `    ``}` `    ``// Structure to represent a directed` `    ``// and weighted graph` `    ``class` `Graph {`   `        ``// V. Number of vertices, E. Number of edges` `        ``public` `int` `V, E;`   `        ``// graph is represented as an array of edges.` `        ``public` `Edge[] edge;` `    ``}`   `    ``// Creates a new graph with V vertices` `    ``// and E edges` `    ``static` `Graph createGraph(``int` `V, ``int` `E)` `    ``{` `        ``Graph graph = ``new` `Graph();` `        ``graph.V = V;` `        ``graph.E = E;` `        ``graph.edge = ``new` `Edge[graph.E];`   `        ``for` `(``int` `i = 0; i < graph.E; i++) {` `            ``graph.edge[i] = ``new` `Edge();` `        ``}`   `        ``return` `graph;` `    ``}`   `    ``// Function runs Bellman-Ford algorithm` `    ``// and prints negative cycle(if present)` `    ``static` `void` `NegCycleBellmanFord(Graph graph, ``int` `src)` `    ``{` `        ``int` `V = graph.V;` `        ``int` `E = graph.E;` `        ``int``[] dist = ``new` `int``[V];` `        ``int``[] parent = ``new` `int``[V];`   `        ``// Initialize distances from src` `        ``// to all other vertices as INFINITE` `        ``// and all parent as -1` `        ``for` `(``int` `i = 0; i < V; i++) {`   `            ``dist[i] = 1000000;` `            ``parent[i] = -1;` `        ``}` `        ``dist[src] = 0;`   `        ``// Relax all edges |V| - 1 times.` `        ``for` `(``int` `i = 1; i <= V - 1; i++) {` `            ``for` `(``int` `j = 0; j < E; j++) {`   `                ``int` `u = graph.edge[j].src;` `                ``int` `v = graph.edge[j].dest;` `                ``int` `weight = graph.edge[j].weight;`   `                ``if` `(dist[u] != 1000000` `                    ``&& dist[u] + weight < dist[v]) {`   `                    ``dist[v] = dist[u] + weight;` `                    ``parent[v] = u;` `                ``}` `            ``}` `        ``}`   `        ``// Check for negative-weight cycles` `        ``int` `C = -1;` `        ``for` `(``int` `i = 0; i < E; i++) {`   `            ``int` `u = graph.edge[i].src;` `            ``int` `v = graph.edge[i].dest;` `            ``int` `weight = graph.edge[i].weight;`   `            ``if` `(dist[u] != 1000000` `                ``&& dist[u] + weight < dist[v]) {`   `                ``// Store one of the vertex of` `                ``// the negative weight cycle` `                ``C = v;` `                ``break``;` `            ``}` `        ``}`   `        ``if` `(C != -1) {`   `            ``for` `(``int` `i = 0; i < V; i++)` `                ``C = parent[C];`   `            ``// To store the cycle vertex` `            ``ArrayList cycle = ``new` `ArrayList();` `            ``for` `(``int` `v = C;; v = parent[v]) {`   `                ``cycle.Add(v);` `                ``if` `(v == C && cycle.Count > 1)` `                    ``break``;` `            ``}`   `            ``// Reverse cycle[]` `            ``cycle.Reverse();`   `            ``// Printing the negative cycle` `            ``foreach``(``int` `v ``in` `cycle) Console.Write(v + ``" "``);` `            ``Console.WriteLine();` `        ``}` `        ``else` `            ``Console.WriteLine(-1);` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main(``string``[] args)` `    ``{`   `        ``// Number of vertices in graph` `        ``int` `V = 5;`   `        ``// Number of edges in graph` `        ``int` `E = 5;`   `        ``Graph graph = createGraph(V, E);`   `        ``// Given Graph` `        ``graph.edge[0].src = 0;` `        ``graph.edge[0].dest = 1;` `        ``graph.edge[0].weight = 1;`   `        ``graph.edge[1].src = 1;` `        ``graph.edge[1].dest = 2;` `        ``graph.edge[1].weight = 2;`   `        ``graph.edge[2].src = 2;` `        ``graph.edge[2].dest = 3;` `        ``graph.edge[2].weight = 3;`   `        ``graph.edge[3].src = 3;` `        ``graph.edge[3].dest = 4;` `        ``graph.edge[3].weight = -3;`   `        ``graph.edge[4].src = 4;` `        ``graph.edge[4].dest = 1;` `        ``graph.edge[4].weight = -3;`   `        ``// Function Call` `        ``NegCycleBellmanFord(graph, 0);` `    ``}` `}`   `// This code is contributed by rutvik_56`

Output:

`1 2 3 4 1`

Time Complexity: O(V*E)
Auxiliary Space: O(V)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up
Recommended Articles
Page :