Bellman-Ford Algorithm - Problem

The Bellman-Ford algorithm is a single-source shortest path algorithm that can handle graphs with negative edge weights, unlike Dijkstra's algorithm. It can also detect negative weight cycles in the graph.

Given a weighted directed graph represented as an edge list and a source vertex, implement the Bellman-Ford algorithm to:

1. Find the shortest distances from the source to all other vertices

2. Detect if there's a negative weight cycle reachable from the source

Return a result object containing:

distances: Array of shortest distances from source to each vertex (use float('inf') for unreachable vertices)
hasNegativeCycle: Boolean indicating whether a negative weight cycle exists

If a negative cycle exists, the distances array should still contain the distances computed before cycle detection.

Input & Output

Example 1 — Basic Graph with Negative Edge

$ Input: n = 5, edges = [[0,1,4],[0,2,2],[1,2,-3],[2,3,3],[1,3,2],[1,4,3],[3,4,1]], source = 0

› Output: {"distances":[0,4,-1,2,3],"hasNegativeCycle":false}

💡 Note: From source 0: direct to 1 costs 4, direct to 2 costs 2, then 2→1 with weight -3 makes path 0→2→1 cost -1, which is better than direct path to 1. No negative cycles exist.

Example 2 — Graph with Negative Cycle

$ Input: n = 3, edges = [[0,1,1],[1,2,-3],[2,1,1]], source = 0

› Output: {"distances":[0,1,-2],"hasNegativeCycle":true}

💡 Note: Path 0→1→2 costs -2, but vertices 1 and 2 form a negative cycle (1→2→1 = -3+1 = -2), allowing infinite cost reduction.

Example 3 — Disconnected Graph

$ Input: n = 4, edges = [[0,1,2],[2,3,-1]], source = 0

› Output: {"distances":[0,2,"Infinity","Infinity"],"hasNegativeCycle":false}

💡 Note: Source 0 can reach vertex 1 with cost 2, but vertices 2 and 3 are unreachable from source 0, so their distances remain infinity.

Constraints

1 ≤ n ≤ 100
0 ≤ edges.length ≤ n*(n-1)
edges[i] = [u, v, weight] where 0 ≤ u, v < n
-100 ≤ weight ≤ 100
0 ≤ source < n

Visualization

Tap to expand

Asked in

G Google 35 a Amazon 28 M Microsoft 22 f Facebook 18

The Bellman-Ford algorithm handles negative edge weights by performing V-1 iterations of edge relaxation, followed by cycle detection. The key insight is that shortest paths in a graph with V vertices use at most V-1 edges. Time: O(VE), Space: O(V).

Common Approaches

✓ Brute Force - Try All Possible Paths

⏱️ Time: O(V^V) Space: O(V)

Generate and evaluate all possible paths of increasing length from the source vertex to every other vertex, keeping track of the minimum cost found.

Standard Bellman-Ford Algorithm

⏱️ Time: O(VE) Space: O(V)

The standard Bellman-Ford algorithm performs exactly (V-1) iterations of edge relaxation, followed by one additional iteration to detect negative weight cycles.

Brute Force - Try All Possible Paths — Algorithm Steps

Step 1: For each vertex, try all paths of length 1, 2, ..., n-1
Step 2: Keep track of minimum distance found for each vertex
Step 3: Check for negative cycles by seeing if longer paths give better results

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set source distance to 0, others to infinity

Path Length 1

Try all 1-edge paths from source

Path Length 2

Try all 2-edge paths, update if better

Continue

Repeat for increasing path lengths

Check Cycles

Final pass detects negative cycles

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <float.h>
#include <stdbool.h>

typedef struct {
    double *distances;
    bool hasNegativeCycle;
    int n;
} Result;

Result solution(int n, int edges[][3], int edgeCount, int source) {
    Result result;
    result.distances = malloc(n * sizeof(double));
    result.n = n;
    
    // Initialize distances
    for (int i = 0; i < n; i++) {
        result.distances[i] = DBL_MAX;
    }
    result.distances[source] = 0;
    
    // Try all possible path lengths
    for (int pathLength = 1; pathLength < n; pathLength++) {
        bool updated = false;
        // Try to extend each current shortest path
        for (int i = 0; i < edgeCount; i++) {
            int u = edges[i][0], v = edges[i][1], weight = edges[i][2];
            if (result.distances[u] != DBL_MAX && result.distances[u] + weight < result.distances[v]) {
                result.distances[v] = result.distances[u] + weight;
                updated = true;
            }
        }
        if (!updated) break;
    }
    
    // Check for negative cycle
    result.hasNegativeCycle = false;
    for (int i = 0; i < edgeCount; i++) {
        int u = edges[i][0], v = edges[i][1], weight = edges[i][2];
        if (result.distances[u] != DBL_MAX && result.distances[u] + weight < result.distances[v]) {
            result.hasNegativeCycle = true;
            break;
        }
    }
    
    return result;
}

int main() {
    int n, source;
    scanf("%d", &n);
    
    // Simplified edge parsing for demo
    int edges[7][3] = {{0,1,4},{0,2,2},{1,2,-3},{2,3,3},{1,3,2},{1,4,3},{3,4,1}};
    int edgeCount = 7;
    
    scanf("%d", &source);
    
    Result result = solution(n, edges, edgeCount, source);
    
    printf("{\"distances\":[");
    for (int i = 0; i < n; i++) {
        if (i > 0) printf(",");
        if (result.distances[i] == DBL_MAX) {
            printf("\"Infinity\"");
        } else {
            printf("%.0f", result.distances[i]);
        }
    }
    printf("],\"hasNegativeCycle\":%s}\n", result.hasNegativeCycle ? "true" : "false");
    
    free(result.distances);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(V^V)

Tries all possible paths, which can be exponential in number of vertices

✓ Linear Growth

Space Complexity

O(V)

Only stores distance array and current path being explored

✓ Linear Space

23.4K Views

Medium Frequency

~35 min Avg. Time

890 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Bellman-Ford Algorithm - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Possible Paths — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler