GeeksforGeeks App
Open App
Browser
Continue

# Detect a negative cycle in a Graph | (Bellman Ford)

We are given a directed graph. We need to compute whether the graph has a negative cycle or not. A negative cycle is one in which the overall sum of the cycle becomes negative.

Negative weights are found in various applications of graphs. For example, instead of paying cost for a path, we may get some advantage if we follow the path.

Examples:

```Input : 4 4
0 1 1
1 2 -1
2 3 -1
3 0 -1

Output : Yes
The graph contains a negative cycle.```

Recommended: Please solve it on “PRACTICE ” first, before moving on to the solution.

The idea is to use Bellman-Ford Algorithm

Below is an algorithm to find if there is a negative weight cycle reachable from the given source.

1. Initialize distances from the source to all vertices as infinite and distance to the source itself as 0. Create an array dist[] of size |V| with all values as infinite except dist[src] where src is the source vertex.
2. This step calculates the shortest distances. Do the following |V|-1 times where |V| is the number of vertices in the given graph.
1. Do the following for each edge u-v.
2. If dist[v] > dist[u] + weight of edge uv, then update dist[v].
3. dist[v] = dist[u] + weight of edge uv.
3. This step reports if there is a negative weight cycle in the graph. Do the following for each edge u-v
1. If dist[v] > dist[u] + weight of edge uv, then the “Graph has a negative weight cycle”

The idea of step 3 is, step 2 guarantees the shortest distances if the graph doesn’t contain a negative weight cycle. If we iterate through all edges one more time and get a shorter path for any vertex, then there is a negative weight cycle.

Implementation:

## C++

 `// A C++ program to check if a graph contains negative``// weight cycle using Bellman-Ford algorithm. This program``// works only if all vertices are reachable from a source``// vertex 0.``#include ``using` `namespace` `std;` `// a structure to represent a weighted edge in graph``struct` `Edge {``    ``int` `src, dest, weight;``};` `// a structure to represent a connected, 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 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;``}` `// The main function that finds shortest distances``// from src to all other vertices using Bellman-``// Ford algorithm.  The function also detects``// negative weight cycle``bool` `isNegCycleBellmanFord(``struct` `Graph* graph,``                           ``int` `src)``{``    ``int` `V = graph->V;``    ``int` `E = graph->E;``    ``int` `dist[V];` `    ``// Step 1: Initialize distances from src``    ``// to all other vertices as INFINITE``    ``for` `(``int` `i = 0; i < V; i++)``        ``dist[i] = INT_MAX;``    ``dist[src] = 0;` `    ``// Step 2: Relax all edges |V| - 1 times.``    ``// A simple shortest path from src to any``    ``// other vertex can have at-most |V| - 1``    ``// edges``    ``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;``        ``}``    ``}` `    ``// Step 3: check for negative-weight cycles.``    ``// The above step guarantees shortest distances``    ``// if graph doesn't contain negative weight cycle.``    ``// If we get a shorter path, then there``    ``// is a cycle.``    ``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])``            ``return` `true``;``    ``}` `    ``return` `false``;``}` `// Driver program to test above functions``int` `main()``{``    ``/* Let us create the graph given in above example */``    ``int` `V = 5; ``// Number of vertices in graph``    ``int` `E = 8; ``// Number of edges in graph``    ``struct` `Graph* graph = createGraph(V, E);` `    ``// add edge 0-1 (or A-B in above figure)``    ``graph->edge[0].src = 0;``    ``graph->edge[0].dest = 1;``    ``graph->edge[0].weight = -1;` `    ``// add edge 0-2 (or A-C in above figure)``    ``graph->edge[1].src = 0;``    ``graph->edge[1].dest = 2;``    ``graph->edge[1].weight = 4;` `    ``// add edge 1-2 (or B-C in above figure)``    ``graph->edge[2].src = 1;``    ``graph->edge[2].dest = 2;``    ``graph->edge[2].weight = 3;` `    ``// add edge 1-3 (or B-D in above figure)``    ``graph->edge[3].src = 1;``    ``graph->edge[3].dest = 3;``    ``graph->edge[3].weight = 2;` `    ``// add edge 1-4 (or A-E in above figure)``    ``graph->edge[4].src = 1;``    ``graph->edge[4].dest = 4;``    ``graph->edge[4].weight = 2;` `    ``// add edge 3-2 (or D-C in above figure)``    ``graph->edge[5].src = 3;``    ``graph->edge[5].dest = 2;``    ``graph->edge[5].weight = 5;` `    ``// add edge 3-1 (or D-B in above figure)``    ``graph->edge[6].src = 3;``    ``graph->edge[6].dest = 1;``    ``graph->edge[6].weight = 1;` `    ``// add edge 4-3 (or E-D in above figure)``    ``graph->edge[7].src = 4;``    ``graph->edge[7].dest = 3;``    ``graph->edge[7].weight = -3;` `    ``if` `(isNegCycleBellmanFord(graph, 0))``        ``cout << ``"Yes"``;``    ``else``        ``cout << ``"No"``;` `    ``return` `0;``}`

## Java

 `// Java program to check if a graph contains negative``// weight cycle using Bellman-Ford algorithm. This program``// works only if all vertices are reachable from a source``// vertex 0.``import` `java.util.*;` `class` `GFG {` `    ``// a structure to represent a weighted edge in graph``    ``static` `class` `Edge {``        ``int` `src, dest, weight;``    ``}` `    ``// a structure to represent a connected, 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 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;``    ``}` `    ``// The main function that finds shortest distances``    ``// from src to all other vertices using Bellman-``    ``// Ford algorithm. The function also detects``    ``// negative weight cycle``    ``static` `boolean` `isNegCycleBellmanFord(Graph graph, ``int` `src) {``        ``int` `V = graph.V;``        ``int` `E = graph.E;``        ``int``[] dist = ``new` `int``[V];` `        ``// Step 1: Initialize distances from src``        ``// to all other vertices as INFINITE``        ``for` `(``int` `i = ``0``; i < V; i++)``            ``dist[i] = Integer.MAX_VALUE;``        ``dist[src] = ``0``;` `        ``// Step 2: Relax all edges |V| - 1 times.``        ``// A simple shortest path from src to any``        ``// other vertex can have at-most |V| - 1``        ``// edges``        ``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] != Integer.MAX_VALUE && dist[u] + weight < dist[v])``                    ``dist[v] = dist[u] + weight;``            ``}``        ``}` `        ``// Step 3: check for negative-weight cycles.``        ``// The above step guarantees shortest distances``        ``// if graph doesn't contain negative weight cycle.``        ``// If we get a shorter path, then there``        ``// is a cycle.``        ``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] != Integer.MAX_VALUE && dist[u] + weight < dist[v])``                ``return` `true``;``        ``}` `        ``return` `false``;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args) {``        ``int` `V = ``5``, E = ``8``;``        ``Graph graph = createGraph(V, E);` `        ``// add edge 0-1 (or A-B in above figure)``        ``graph.edge[``0``].src = ``0``;``        ``graph.edge[``0``].dest = ``1``;``        ``graph.edge[``0``].weight = -``1``;` `        ``// add edge 0-2 (or A-C in above figure)``        ``graph.edge[``1``].src = ``0``;``        ``graph.edge[``1``].dest = ``2``;``        ``graph.edge[``1``].weight = ``4``;` `        ``// add edge 1-2 (or B-C in above figure)``        ``graph.edge[``2``].src = ``1``;``        ``graph.edge[``2``].dest = ``2``;``        ``graph.edge[``2``].weight = ``3``;` `        ``// add edge 1-3 (or B-D in above figure)``        ``graph.edge[``3``].src = ``1``;``        ``graph.edge[``3``].dest = ``3``;``        ``graph.edge[``3``].weight = ``2``;` `        ``// add edge 1-4 (or A-E in above figure)``        ``graph.edge[``4``].src = ``1``;``        ``graph.edge[``4``].dest = ``4``;``        ``graph.edge[``4``].weight = ``2``;` `        ``// add edge 3-2 (or D-C in above figure)``        ``graph.edge[``5``].src = ``3``;``        ``graph.edge[``5``].dest = ``2``;``        ``graph.edge[``5``].weight = ``5``;` `        ``// add edge 3-1 (or D-B in above figure)``        ``graph.edge[``6``].src = ``3``;``        ``graph.edge[``6``].dest = ``1``;``        ``graph.edge[``6``].weight = ``1``;` `        ``// add edge 4-3 (or E-D in above figure)``        ``graph.edge[``7``].src = ``4``;``        ``graph.edge[``7``].dest = ``3``;``        ``graph.edge[``7``].weight = -``3``;` `        ``if` `(isNegCycleBellmanFord(graph, ``0``))``            ``System.out.println(``"Yes"``);``        ``else``            ``System.out.println(``"No"``);``    ``}``}` `// This code is contributed by``// sanjeev2552`

## Python3

 `# A Python3 program to check if a graph contains negative``# weight cycle using Bellman-Ford algorithm. This program``# works only if all vertices are reachable from a source``# vertex 0.` `# a structure to represent a weighted edge in graph``class` `Edge:``    ` `    ``def` `__init__(``self``):``        ``self``.src ``=` `0``        ``self``.dest ``=` `0``        ``self``.weight ``=` `0` `# a structure to represent a connected, 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 ``=` `None` `# Creates a 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;` `# The main function that finds shortest distances``# from src to all other vertices using Bellman-``# Ford algorithm.  The function also detects``# negative weight cycle``def` `isNegCycleBellmanFord(graph, src):` `    ``V ``=` `graph.V;``    ``E ``=` `graph.E;``    ``dist ``=` `[``1000000` `for` `i ``in` `range``(V)];``    ``dist[src] ``=` `0``;` `    ``# Step 2: Relax all edges |V| - 1 times.``    ``# A simple shortest path from src to any``    ``# other vertex can have at-most |V| - 1``    ``# edges``    ``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;` `    ``# Step 3: check for negative-weight cycles.``    ``# The above step guarantees shortest distances``    ``# if graph doesn't contain negative weight cycle.``    ``# If we get a shorter path, then there``    ``# is a cycle.``    ``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]):``            ``return` `True``;` `    ``return` `False``;` `# Driver program to test above functions``if` `__name__``=``=``'__main__'``:``    ` `    ``# Let us create the graph given in above example``    ``V ``=` `5``; ``# Number of vertices in graph``    ``E ``=` `8``; ``# Number of edges in graph``    ``graph ``=` `createGraph(V, E);` `    ``# add edge 0-1 (or A-B in above figure)``    ``graph.edge[``0``].src ``=` `0``;``    ``graph.edge[``0``].dest ``=` `1``;``    ``graph.edge[``0``].weight ``=` `-``1``;` `    ``# add edge 0-2 (or A-C in above figure)``    ``graph.edge[``1``].src ``=` `0``;``    ``graph.edge[``1``].dest ``=` `2``;``    ``graph.edge[``1``].weight ``=` `4``;` `    ``# add edge 1-2 (or B-C in above figure)``    ``graph.edge[``2``].src ``=` `1``;``    ``graph.edge[``2``].dest ``=` `2``;``    ``graph.edge[``2``].weight ``=` `3``;` `    ``# add edge 1-3 (or B-D in above figure)``    ``graph.edge[``3``].src ``=` `1``;``    ``graph.edge[``3``].dest ``=` `3``;``    ``graph.edge[``3``].weight ``=` `2``;` `    ``# add edge 1-4 (or A-E in above figure)``    ``graph.edge[``4``].src ``=` `1``;``    ``graph.edge[``4``].dest ``=` `4``;``    ``graph.edge[``4``].weight ``=` `2``;` `    ``# add edge 3-2 (or D-C in above figure)``    ``graph.edge[``5``].src ``=` `3``;``    ``graph.edge[``5``].dest ``=` `2``;``    ``graph.edge[``5``].weight ``=` `5``;` `    ``# add edge 3-1 (or D-B in above figure)``    ``graph.edge[``6``].src ``=` `3``;``    ``graph.edge[``6``].dest ``=` `1``;``    ``graph.edge[``6``].weight ``=` `1``;` `    ``# add edge 4-3 (or E-D in above figure)``    ``graph.edge[``7``].src ``=` `4``;``    ``graph.edge[``7``].dest ``=` `3``;``    ``graph.edge[``7``].weight ``=` `-``3``;` `    ``if` `(isNegCycleBellmanFord(graph, ``0``)):``        ``print``(``"Yes"``)``    ``else``:``        ``print``(``"No"``)` `        ``# This code is contributed by pratham76`

## C#

 `// C# program to check if a graph contains negative``// weight cycle using Bellman-Ford algorithm. This program``// works only if all vertices are reachable from a source``// vertex 0.``using` `System;``using` `System.Collections;``using` `System.Collections.Generic;`` ` `class` `GFG {`` ` `    ``// a structure to represent a weighted edge in graph``    ``class` `Edge {``        ``public` `int` `src, dest, weight;``    ``}`` ` `    ``// a structure to represent a connected, 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 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;``    ``}`` ` `    ``// The main function that finds shortest distances``    ``// from src to all other vertices using Bellman-``    ``// Ford algorithm. The function also detects``    ``// negative weight cycle``    ``static` `bool` `isNegCycleBellmanFord(Graph graph, ``int` `src) {``        ``int` `V = graph.V;``        ``int` `E = graph.E;``        ``int``[] dist = ``new` `int``[V];`` ` `        ``// Step 1: Initialize distances from src``        ``// to all other vertices as INFINITE``        ``for` `(``int` `i = 0; i < V; i++)``            ``dist[i] = 1000000;``        ``dist[src] = 0;`` ` `        ``// Step 2: Relax all edges |V| - 1 times.``        ``// A simple shortest path from src to any``        ``// other vertex can have at-most |V| - 1``        ``// edges``        ``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;``            ``}``        ``}`` ` `        ``// Step 3: check for negative-weight cycles.``        ``// The above step guarantees shortest distances``        ``// if graph doesn't contain negative weight cycle.``        ``// If we get a shorter path, then there``        ``// is a cycle.``        ``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])``                ``return` `true``;``        ``}`` ` `        ``return` `false``;``    ``}`` ` `    ``// Driver Code``    ``public` `static` `void` `Main(``string``[] args) {``        ``int` `V = 5, E = 8;``        ``Graph graph = createGraph(V, E);`` ` `        ``// add edge 0-1 (or A-B in above figure)``        ``graph.edge[0].src = 0;``        ``graph.edge[0].dest = 1;``        ``graph.edge[0].weight = -1;`` ` `        ``// add edge 0-2 (or A-C in above figure)``        ``graph.edge[1].src = 0;``        ``graph.edge[1].dest = 2;``        ``graph.edge[1].weight = 4;`` ` `        ``// add edge 1-2 (or B-C in above figure)``        ``graph.edge[2].src = 1;``        ``graph.edge[2].dest = 2;``        ``graph.edge[2].weight = 3;`` ` `        ``// add edge 1-3 (or B-D in above figure)``        ``graph.edge[3].src = 1;``        ``graph.edge[3].dest = 3;``        ``graph.edge[3].weight = 2;`` ` `        ``// add edge 1-4 (or A-E in above figure)``        ``graph.edge[4].src = 1;``        ``graph.edge[4].dest = 4;``        ``graph.edge[4].weight = 2;`` ` `        ``// add edge 3-2 (or D-C in above figure)``        ``graph.edge[5].src = 3;``        ``graph.edge[5].dest = 2;``        ``graph.edge[5].weight = 5;`` ` `        ``// add edge 3-1 (or D-B in above figure)``        ``graph.edge[6].src = 3;``        ``graph.edge[6].dest = 1;``        ``graph.edge[6].weight = 1;`` ` `        ``// add edge 4-3 (or E-D in above figure)``        ``graph.edge[7].src = 4;``        ``graph.edge[7].dest = 3;``        ``graph.edge[7].weight = -3;`` ` `        ``if` `(isNegCycleBellmanFord(graph, 0))``            ``Console.Write(``"Yes"``);``        ``else``            ``Console.Write(``"No"``);``    ``}``}` `// This code is contributed by rutvik_56`

## Javascript

 ``

Output

`No`

Time Complexity: O(VE), where V is the number of vertices and E is the number of edges in the graph.

Space Complexity: O(V), where V is the number of vertices in the graph.

How does it work?
As discussed, the Bellman-Ford algorithm, for a given source, first calculates the shortest distances which have at most one edge in the path. Then, it calculates the shortest paths with at-most 2 edges, and so on. After the i-th iteration of the outer loop, the shortest paths with at most i edges are calculated. There can be a maximum |V| – 1 edge on any simple path, that is why the outer loop runs |v| – 1 time. If there is a negative weight cycle, then one more iteration would give a short route.

How to handle a disconnected graph (If the cycle is not reachable from the source)?
The above algorithm and program might not work if the given graph is disconnected. It works when all vertices are reachable from source vertex 0.
To handle disconnected graphs, we can repeat the process for vertices for which distance is infinite.

Implementation:

## C++

 `// A C++ program for Bellman-Ford's single source``// shortest path algorithm.``#include ``using` `namespace` `std;` `// a structure to represent a weighted edge in graph``struct` `Edge {``    ``int` `src, dest, weight;``};` `// a structure to represent a connected, 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 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;``}` `// The main function that finds shortest distances``// from src to all other vertices using Bellman-``// Ford algorithm. The function also detects``// negative weight cycle``bool` `isNegCycleBellmanFord(``struct` `Graph* graph,``                           ``int` `src, ``int` `dist[])``{``    ``int` `V = graph->V;``    ``int` `E = graph->E;` `    ``// Step 1: Initialize distances from src``    ``// to all other vertices as INFINITE``    ``for` `(``int` `i = 0; i < V; i++)``        ``dist[i] = INT_MAX;``    ``dist[src] = 0;` `    ``// Step 2: Relax all edges |V| - 1 times.``    ``// A simple shortest path from src to any``    ``// other vertex can have at-most |V| - 1``    ``// edges``    ``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;``        ``}``    ``}` `    ``// Step 3: check for negative-weight cycles.``    ``// The above step guarantees shortest distances``    ``// if graph doesn't contain negative weight cycle.``    ``// If we get a shorter path, then there``    ``// is a cycle.``    ``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])``            ``return` `true``;``    ``}` `    ``return` `false``;``}` `// Returns true if given graph has negative weight``// cycle.``bool` `isNegCycleDisconnected(``struct` `Graph* graph)``{` `    ``int` `V = graph->V;``    ``// To keep track of visited vertices to avoid``    ``// recomputations.``    ``bool` `visited[V];``    ``memset``(visited, 0, ``sizeof``(visited));` `    ``// This array is filled by Bellman-Ford``    ``int` `dist[V];` `    ``// Call Bellman-Ford for all those vertices``    ``// that are not visited``    ``for` `(``int` `i = 0; i < V; i++) {``        ``if` `(visited[i] == ``false``) {``            ``// If cycle found``            ``if` `(isNegCycleBellmanFord(graph, i, dist))``                ``return` `true``;` `            ``// Mark all vertices that are visited``            ``// in above call.``            ``for` `(``int` `i = 0; i < V; i++)``                ``if` `(dist[i] != INT_MAX)``                    ``visited[i] = ``true``;``        ``}``    ``}` `    ``return` `false``;``}` `// Driver program to test above functions``int` `main()``{``    ``/* Let us create the graph given in above example */``    ``int` `V = 5; ``// Number of vertices in graph``    ``int` `E = 8; ``// Number of edges in graph``    ``struct` `Graph* graph = createGraph(V, E);` `    ``// add edge 0-1 (or A-B in above figure)``    ``graph->edge[0].src = 0;``    ``graph->edge[0].dest = 1;``    ``graph->edge[0].weight = -1;` `    ``// add edge 0-2 (or A-C in above figure)``    ``graph->edge[1].src = 0;``    ``graph->edge[1].dest = 2;``    ``graph->edge[1].weight = 4;` `    ``// add edge 1-2 (or B-C in above figure)``    ``graph->edge[2].src = 1;``    ``graph->edge[2].dest = 2;``    ``graph->edge[2].weight = 3;` `    ``// add edge 1-3 (or B-D in above figure)``    ``graph->edge[3].src = 1;``    ``graph->edge[3].dest = 3;``    ``graph->edge[3].weight = 2;` `    ``// add edge 1-4 (or A-E in above figure)``    ``graph->edge[4].src = 1;``    ``graph->edge[4].dest = 4;``    ``graph->edge[4].weight = 2;` `    ``// add edge 3-2 (or D-C in above figure)``    ``graph->edge[5].src = 3;``    ``graph->edge[5].dest = 2;``    ``graph->edge[5].weight = 5;` `    ``// add edge 3-1 (or D-B in above figure)``    ``graph->edge[6].src = 3;``    ``graph->edge[6].dest = 1;``    ``graph->edge[6].weight = 1;` `    ``// add edge 4-3 (or E-D in above figure)``    ``graph->edge[7].src = 4;``    ``graph->edge[7].dest = 3;``    ``graph->edge[7].weight = -3;` `    ``if` `(isNegCycleDisconnected(graph))``        ``cout << ``"Yes"``;``    ``else``        ``cout << ``"No"``;` `    ``return` `0;``}`

## Java

 `// A Java program for Bellman-Ford's single source``// shortest path algorithm.``import` `java.util.*;` `class` `GFG{` `// A structure to represent a weighted``// edge in graph``static` `class` `Edge``{``    ``int` `src, dest, weight;``}` `// A structure to represent a connected,``// 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 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;``}` `// The main function that finds shortest distances``// from src to all other vertices using Bellman-``// Ford algorithm. The function also detects``// negative weight cycle``static` `boolean` `isNegCycleBellmanFord(Graph graph,``                                     ``int` `src,``                                     ``int` `dist[])``{``    ``int` `V = graph.V;``    ``int` `E = graph.E;``  ` `    ``// Step 1: Initialize distances from src``    ``// to all other vertices as INFINITE``    ``for``(``int` `i = ``0``; i < V; i++)``        ``dist[i] = Integer.MAX_VALUE;``        ` `    ``dist[src] = ``0``;``  ` `    ``// Step 2: Relax all edges |V| - 1 times.``    ``// A simple shortest path from src to any``    ``// other vertex can have at-most |V| - 1``    ``// edges``    ``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] != Integer.MAX_VALUE &&``                ``dist[u] + weight < dist[v])``                ``dist[v] = dist[u] + weight;``        ``}``    ``}``  ` `    ``// Step 3: check for negative-weight cycles.``    ``// The above step guarantees shortest distances``    ``// if graph doesn't contain negative weight cycle.``    ``// If we get a shorter path, then there``    ``// is a cycle.``    ``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] != Integer.MAX_VALUE &&``            ``dist[u] + weight < dist[v])``            ``return` `true``;``    ``}``  ` `    ``return` `false``;``}` `// Returns true if given graph has negative weight``// cycle.``static` `boolean` `isNegCycleDisconnected(Graph graph)``{``    ``int` `V = graph.V;``    ` `    ``// To keep track of visited vertices``    ``// to avoid recomputations.``    ``boolean` `visited[] = ``new` `boolean``[V];``    ``Arrays.fill(visited, ``false``);``  ` `    ``// This array is filled by Bellman-Ford``    ``int` `dist[] = ``new` `int``[V];` `    ``// Call Bellman-Ford for all those vertices``    ``// that are not visited``    ``for``(``int` `i = ``0``; i < V; i++)``    ``{``        ``if` `(visited[i] == ``false``)``        ``{``            ` `            ``// If cycle found``            ``if` `(isNegCycleBellmanFord(graph, i, dist))``                ``return` `true``;``  ` `            ``// Mark all vertices that are visited``            ``// in above call.``            ``for``(``int` `j = ``0``; j < V; j++)``                ``if` `(dist[j] != Integer.MAX_VALUE)``                    ``visited[j] = ``true``;``        ``}``    ``}``    ``return` `false``;``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `V = ``5``, E = ``8``;``    ``Graph graph = createGraph(V, E);` `    ``// Add edge 0-1 (or A-B in above figure)``    ``graph.edge[``0``].src = ``0``;``    ``graph.edge[``0``].dest = ``1``;``    ``graph.edge[``0``].weight = -``1``;` `    ``// Add edge 0-2 (or A-C in above figure)``    ``graph.edge[``1``].src = ``0``;``    ``graph.edge[``1``].dest = ``2``;``    ``graph.edge[``1``].weight = ``4``;` `    ``// Add edge 1-2 (or B-C in above figure)``    ``graph.edge[``2``].src = ``1``;``    ``graph.edge[``2``].dest = ``2``;``    ``graph.edge[``2``].weight = ``3``;` `    ``// Add edge 1-3 (or B-D in above figure)``    ``graph.edge[``3``].src = ``1``;``    ``graph.edge[``3``].dest = ``3``;``    ``graph.edge[``3``].weight = ``2``;` `    ``// Add edge 1-4 (or A-E in above figure)``    ``graph.edge[``4``].src = ``1``;``    ``graph.edge[``4``].dest = ``4``;``    ``graph.edge[``4``].weight = ``2``;` `    ``// Add edge 3-2 (or D-C in above figure)``    ``graph.edge[``5``].src = ``3``;``    ``graph.edge[``5``].dest = ``2``;``    ``graph.edge[``5``].weight = ``5``;` `    ``// Add edge 3-1 (or D-B in above figure)``    ``graph.edge[``6``].src = ``3``;``    ``graph.edge[``6``].dest = ``1``;``    ``graph.edge[``6``].weight = ``1``;` `    ``// Add edge 4-3 (or E-D in above figure)``    ``graph.edge[``7``].src = ``4``;``    ``graph.edge[``7``].dest = ``3``;``    ``graph.edge[``7``].weight = -``3``;` `    ``if` `(isNegCycleDisconnected(graph))``        ``System.out.println(``"Yes"``);``    ``else``        ``System.out.println(``"No"``);``}``}` `// This code is contributed by adityapande88`

## Python3

 `# A Python3 program for Bellman-Ford's single source``# shortest path algorithm.` `# The main function that finds shortest distances``# from src to all other vertices using Bellman-``# Ford algorithm. The function also detects``# negative weight cycle``def` `isNegCycleBellmanFord(src, dist):``    ``global` `graph, V, E` `    ``# Step 1: Initialize distances from src``    ``# to all other vertices as INFINITE``    ``for` `i ``in` `range``(V):``        ``dist[i] ``=` `10``*``*``18``    ``dist[src] ``=` `0` `    ``# Step 2: Relax all edges |V| - 1 times.``    ``# A simple shortest path from src to any``    ``# other vertex can have at-most |V| - 1``    ``# edges``    ``for` `i ``in` `range``(``1``,V):``        ``for` `j ``in` `range``(E):``            ``u ``=` `graph[j][``0``]``            ``v ``=` `graph[j][``1``]``            ``weight ``=` `graph[j][``2``]``            ``if` `(dist[u] !``=` `10``*``*``18` `and` `dist[u] ``+` `weight < dist[v]):``                ``dist[v] ``=` `dist[u] ``+` `weight` `    ``# Step 3: check for negative-weight cycles.``    ``# The above step guarantees shortest distances``    ``# if graph doesn't contain negative weight cycle.``    ``# If we get a shorter path, then there``    ``# is a cycle.``    ``for` `i ``in` `range``(E):``        ``u ``=` `graph[i][``0``]``        ``v ``=` `graph[i][``1``]``        ``weight ``=` `graph[i][``2``]``        ``if` `(dist[u] !``=` `10``*``*``18` `and` `dist[u] ``+` `weight < dist[v]):``            ``return` `True` `    ``return` `False``# Returns true if given graph has negative weight``# cycle.``def` `isNegCycleDisconnected():``    ``global` `V, E, graph``    ` `    ``# To keep track of visited vertices to avoid``    ``# recomputations.``    ``visited ``=` `[``0``]``*``V``    ``# memset(visited, 0, sizeof(visited))` `    ``# This array is filled by Bellman-Ford``    ``dist ``=` `[``0``]``*``V` `    ``# Call Bellman-Ford for all those vertices``    ``# that are not visited``    ``for` `i ``in` `range``(V):``        ``if` `(visited[i] ``=``=` `0``):``            ` `            ``# If cycle found``            ``if` `(isNegCycleBellmanFord(i, dist)):``                ``return` `True` `            ``# Mark all vertices that are visited``            ``# in above call.``            ``for` `i ``in` `range``(V):``                ``if` `(dist[i] !``=` `10``*``*``18``):``                    ``visited[i] ``=` `True``    ``return` `False` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``# /* Let us create the graph given in above example */``    ``V ``=` `5` `# Number of vertices in graph``    ``E ``=` `8` `# Number of edges in graph``    ``graph ``=` `[[``0``, ``0``, ``0``] ``for` `i ``in` `range``(``8``)]` `    ``# add edge 0-1 (or A-B in above figure)``    ``graph[``0``][``0``] ``=` `0``    ``graph[``0``][``1``] ``=` `1``    ``graph[``0``][``2``] ``=` `-``1` `    ``# add edge 0-2 (or A-C in above figure)``    ``graph[``1``][``0``] ``=` `0``    ``graph[``1``][``1``] ``=` `2``    ``graph[``1``][``2``] ``=` `4` `    ``# add edge 1-2 (or B-C in above figure)``    ``graph[``2``][``0``] ``=` `1``    ``graph[``2``][``1``] ``=` `2``    ``graph[``2``][``2``] ``=` `3` `    ``# add edge 1-3 (or B-D in above figure)``    ``graph[``3``][``0``] ``=` `1``    ``graph[``3``][``1``] ``=` `3``    ``graph[``3``][``2``] ``=` `2` `    ``# add edge 1-4 (or A-E in above figure)``    ``graph[``4``][``0``] ``=` `1``    ``graph[``4``][``1``] ``=` `4``    ``graph[``4``][``2``] ``=` `2` `    ``# add edge 3-2 (or D-C in above figure)``    ``graph[``5``][``0``] ``=` `3``    ``graph[``5``][``1``] ``=` `2``    ``graph[``5``][``2``] ``=` `5` `    ``# add edge 3-1 (or D-B in above figure)``    ``graph[``6``][``0``] ``=` `3``    ``graph[``6``][``1``] ``=` `1``    ``graph[``6``][``2``] ``=` `1` `    ``# add edge 4-3 (or E-D in above figure)``    ``graph[``7``][``0``] ``=` `4``    ``graph[``7``][``1``] ``=` `3``    ``graph[``7``][``2``] ``=` `-``3` `    ``if` `(isNegCycleDisconnected()):``        ``print``(``"Yes"``)``    ``else``:``        ``print``(``"No"``)` `# This code is contributed by mohit kumar 29`

## C#

 `// A C# program for Bellman-Ford's single source``// shortest path algorithm.``using` `System;``using` `System.Collections.Generic;``public` `class` `GFG``{` `  ``// A structure to represent a weighted``  ``// edge in graph``  ``public``    ``class` `Edge``    ``{``      ``public``        ``int` `src, dest, weight;``    ``}` `  ``// A structure to represent a connected,``  ``// directed and weighted graph``  ``public``    ``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 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;``  ``}` `  ``// The main function that finds shortest distances``  ``// from src to all other vertices using Bellman-``  ``// Ford algorithm. The function also detects``  ``// negative weight cycle``  ``static` `bool` `isNegCycleBellmanFord(Graph graph,``                                    ``int` `src,``                                    ``int` `[]dist)``  ``{``    ``int` `V = graph.V;``    ``int` `E = graph.E;` `    ``// Step 1: Initialize distances from src``    ``// to all other vertices as INFINITE``    ``for``(``int` `i = 0; i < V; i++)``      ``dist[i] = ``int``.MaxValue;` `    ``dist[src] = 0;` `    ``// Step 2: Relax all edges |V| - 1 times.``    ``// A simple shortest path from src to any``    ``// other vertex can have at-most |V| - 1``    ``// edges``    ``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``.MaxValue &&``            ``dist[u] + weight < dist[v])``          ``dist[v] = dist[u] + weight;``      ``}``    ``}` `    ``// Step 3: check for negative-weight cycles.``    ``// The above step guarantees shortest distances``    ``// if graph doesn't contain negative weight cycle.``    ``// If we get a shorter path, then there``    ``// is a cycle.``    ``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``.MaxValue &&``          ``dist[u] + weight < dist[v])``        ``return` `true``;``    ``}` `    ``return` `false``;``  ``}` `  ``// Returns true if given graph has negative weight``  ``// cycle.``  ``static` `bool` `isNegCycleDisconnected(Graph graph)``  ``{``    ``int` `V = graph.V;` `    ``// To keep track of visited vertices``    ``// to avoid recomputations.``    ``bool` `[]visited = ``new` `bool``[V];`  `    ``// This array is filled by Bellman-Ford``    ``int` `[]dist = ``new` `int``[V];` `    ``// Call Bellman-Ford for all those vertices``    ``// that are not visited``    ``for``(``int` `i = 0; i < V; i++)``    ``{``      ``if` `(visited[i] == ``false``)``      ``{` `        ``// If cycle found``        ``if` `(isNegCycleBellmanFord(graph, i, dist))``          ``return` `true``;` `        ``// Mark all vertices that are visited``        ``// in above call.``        ``for``(``int` `j = 0; j < V; j++)``          ``if` `(dist[j] != ``int``.MaxValue)``            ``visited[j] = ``true``;``      ``}``    ``}``    ``return` `false``;``  ``}` `  ``// Driver Code``  ``public` `static` `void` `Main(String[] args)``  ``{``    ``int` `V = 5, E = 8;``    ``Graph graph = createGraph(V, E);` `    ``// Add edge 0-1 (or A-B in above figure)``    ``graph.edge[0].src = 0;``    ``graph.edge[0].dest = 1;``    ``graph.edge[0].weight = -1;` `    ``// Add edge 0-2 (or A-C in above figure)``    ``graph.edge[1].src = 0;``    ``graph.edge[1].dest = 2;``    ``graph.edge[1].weight = 4;` `    ``// Add edge 1-2 (or B-C in above figure)``    ``graph.edge[2].src = 1;``    ``graph.edge[2].dest = 2;``    ``graph.edge[2].weight = 3;` `    ``// Add edge 1-3 (or B-D in above figure)``    ``graph.edge[3].src = 1;``    ``graph.edge[3].dest = 3;``    ``graph.edge[3].weight = 2;` `    ``// Add edge 1-4 (or A-E in above figure)``    ``graph.edge[4].src = 1;``    ``graph.edge[4].dest = 4;``    ``graph.edge[4].weight = 2;` `    ``// Add edge 3-2 (or D-C in above figure)``    ``graph.edge[5].src = 3;``    ``graph.edge[5].dest = 2;``    ``graph.edge[5].weight = 5;` `    ``// Add edge 3-1 (or D-B in above figure)``    ``graph.edge[6].src = 3;``    ``graph.edge[6].dest = 1;``    ``graph.edge[6].weight = 1;` `    ``// Add edge 4-3 (or E-D in above figure)``    ``graph.edge[7].src = 4;``    ``graph.edge[7].dest = 3;``    ``graph.edge[7].weight = -3;` `    ``if` `(isNegCycleDisconnected(graph))``      ``Console.WriteLine(``"Yes"``);``    ``else``      ``Console.WriteLine(``"No"``);``  ``}``}` `// This code is contributed by aashish1995`

## Javascript

 ``

Output

`No`

Time complexity : O(E*V2), where V is the number of vertices and E is the number of edges.

Space Complexity : O(V + E) which is the space required to store the graph.

Detecting negative cycle using Floyd Warshall

This article is contributed by kartik. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

My Personal Notes arrow_drop_up