Bellman Ford Algorithm Negative Weights in DSA Rust - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Bellman-Ford on a graph with negative edge weights

What is the output distances array after running Bellman-Ford on this graph from source vertex 0?

DSA Rust

let edges = vec![
    (0, 1, 4),
    (0, 2, 5),
    (1, 2, -3),
    (2, 3, 4),
    (3, 1, 6),
];

let vertices = 4;
let source = 0;

let mut dist = vec![i32::MAX; vertices];
dist[source] = 0;

for _ in 0..vertices - 1 {
    for &(u, v, w) in &edges {
        if dist[u] != i32::MAX && dist[u] + w < dist[v] {
            dist[v] = dist[u] + w;
        }
    }
}

println!("{:?}", dist);

A [0, 4, 5, 9]

B [0, 4, 1, 5]

C [0, 4, 1, 9]

D [0, 1, -3, 1]

💡 Hint

Remember Bellman-Ford relaxes edges multiple times to find shortest paths even with negative weights.

The algorithm updates distances step-by-step. Initially, dist[0]=0. Relaxing edges updates dist[1]=4, then dist[2]=1 (via 1->2 with weight -3), and dist[3]=5 (via 2->3 with weight 4).

🧠 Conceptual

intermediate

Detecting negative weight cycles with Bellman-Ford

Which condition correctly detects a negative weight cycle after running Bellman-Ford?

A If any edge can still be relaxed after |V|-1 iterations, a negative weight cycle exists.

B If all distances remain unchanged after the first iteration, a negative weight cycle exists.

C If the distance to the source vertex changes after |V|-1 iterations, a negative weight cycle exists.

D If the sum of all edge weights is negative, a negative weight cycle exists.

💡 Hint

Bellman-Ford runs |V|-1 times to relax edges; extra relaxation means cycle.

After |V|-1 iterations, if any edge can still reduce a distance, it means a cycle with negative total weight exists.

🔧 Debug

advanced

Identify the bug in this Bellman-Ford implementation snippet

What is the bug in this Rust code snippet for Bellman-Ford?

DSA Rust

for _ in 0..vertices {
    for &(u, v, w) in &edges {
        if dist[u] + w < dist[v] {
            dist[v] = dist[u] + w;
        }
    }
}

A The condition dist[u] + w < dist[v] can cause overflow if dist[u] is i32::MAX.

B The source vertex distance is not initialized to zero before the loop.

C The edges vector should be mutable to update distances.

D The loop runs vertices times instead of vertices - 1 times, causing unnecessary extra iteration.

💡 Hint

Check what happens when dist[u] is i32::MAX and you add w.

Adding w to i32::MAX causes integer overflow, leading to incorrect comparisons and wrong results.

🚀 Application

advanced

Using Bellman-Ford to find shortest paths in a graph with negative edges

Given a graph with edges [(0,1,1), (1,2,-1), (2,3,-1), (3,1,-1)], what does Bellman-Ford detect when run from vertex 0?

A It throws a runtime error due to negative weights.

B It finds shortest paths to all vertices without issues.

C It returns infinite distances for all vertices except the source.

D It detects a negative weight cycle reachable from vertex 0.

💡 Hint

Look for cycles where the sum of edge weights is negative.

The cycle 1->2->3->1 has total weight -3, which is negative and reachable from source 0, so Bellman-Ford detects it.

❓ Predict Output

expert

Final distance array after Bellman-Ford with multiple negative edges but no negative cycle

What is the final distance array after running Bellman-Ford from source 0 on this graph? Edges: [(0,1,2), (1,2,-5), (2,3,1), (3,4,2), (4,1,2)] Vertices: 5

DSA Rust

let edges = vec![
    (0, 1, 2),
    (1, 2, -5),
    (2, 3, 1),
    (3, 4, 2),
    (4, 1, 2),
];

let vertices = 5;
let source = 0;

let mut dist = vec![i32::MAX; vertices];
dist[source] = 0;

for _ in 0..vertices - 1 {
    for &(u, v, w) in &edges {
        if dist[u] != i32::MAX && dist[u] + w < dist[v] {
            dist[v] = dist[u] + w;
        }
    }
}

println!("{:?}", dist);

A [0, 2, -5, -4, -2]

B [0, 2, -3, -1, 1]

C [0, 2, -3, -2, 0]

D [0, 2, -3, -2, 1]

💡 Hint

Relax edges multiple times and track distance updates carefully.

Distances update as: dist[1]=2, dist[2]=-3 (2 + -5), dist[3]=-2 (-3 + 1), dist[4]=0 (-2 + 2). The cycle 1->2->3->4->1 has total weight 0, so no negative cycle.

Practice

1. What is the main advantage of the Bellman-Ford algorithm compared to Dijkstra's algorithm?

easy

A. It can handle graphs with negative weight edges.

B. It runs faster on all graphs.

C. It uses less memory.

D. It only works on directed acyclic graphs.

Solution

1. Step 1: Understand the limitation of Dijkstra's algorithm

   Dijkstra's algorithm cannot correctly handle graphs with negative weight edges because it assumes that once a node's shortest path is found, it cannot be improved.

2. Step 2: Identify Bellman-Ford's capability

   Bellman-Ford algorithm can handle negative weight edges and detect negative weight cycles, making it more versatile for such graphs.

3. Final Answer:

   It can handle graphs with negative weight edges. -> Option A

4. Quick Check:

   Negative weights handled = A [OK]

Hint: Bellman-Ford works with negative edges, Dijkstra doesn't [OK]

Common Mistakes:

• Thinking Bellman-Ford is always faster
• Assuming it uses less memory
• Believing it only works on acyclic graphs

2. Which of the following Rust code snippets correctly initializes the distance vector for Bellman-Ford with 5 vertices, starting from vertex 0?

easy

A. let mut dist = vec![i32::MIN; 5]; dist[0] = 0;

B. let mut dist = vec![0; 5]; dist[0] = i32::MAX;

C. let mut dist = vec![0; 5];

D. let mut dist = vec![i32::MAX; 5]; dist[0] = 0;

Solution

1. Step 1: Understand initialization for Bellman-Ford

   Distances to all vertices except the source should be set to a very large number (infinity), here represented by i32::MAX. The source vertex distance is set to 0.

2. Step 2: Check each option

   let mut dist = vec![i32::MAX; 5]; dist[0] = 0; correctly sets all distances to i32::MAX and source (index 0) to 0. Others either invert this or use wrong values.

3. Final Answer:

   let mut dist = vec![i32::MAX; 5]; dist[0] = 0; -> Option D

4. Quick Check:

   Initialize distances with max except source 0 = D [OK]

Hint: Set all distances max except source zero [OK]

Common Mistakes:

• Setting source distance to max instead of zero
• Initializing all distances to zero
• Using i32::MIN which is negative infinity

3. What will be the output distances vector after running one iteration of Bellman-Ford on this graph with edges:
edges = [(0, 1, 4), (0, 2, 5), (1, 2, -3), (2, 3, 4)] starting from vertex 0?
Initial distances: [0, i32::MAX, i32::MAX, i32::MAX]

medium

A. [0, 4, 5, i32::MAX]

B. [0, 4, 1, 5]

C. [0, 4, 5, 9]

D. [0, 4, 1, i32::MAX]

Solution

1. Step 1: Relax edges once from initial distances

   Start distances: [0, MAX, MAX, MAX]. Relax edges:
   - Edge (0->1,4): dist[1] = min(MAX, 0+4) = 4
   - Edge (0->2,5): dist[2] = min(MAX, 0+5) = 5
   - Edge (1->2,-3): dist[2] = min(5, 4-3) = 1
   - Edge (2->3,4): dist[3] = min(MAX, 1+4) = 5

2. Step 2: Determine distances after one iteration

   After relaxing all edges once, distances are [0, 4, 1, 5]. But since the question asks after one iteration (one full pass), all edges are relaxed once, so the final distances are [0, 4, 1, 5].

3. Final Answer:

   [0, 4, 1, 5] -> Option B

4. Quick Check:

   Relax edges once = [0,4,1,5] [OK]

Hint: Relax all edges once to update distances [OK]

Common Mistakes:

• Not relaxing edges in order
• Ignoring negative edge effect
• Stopping after partial relaxation

4. Consider this Rust code snippet for Bellman-Ford. What is the bug causing incorrect detection of negative cycles?

for _ in 0..graph.len() {
    for &(u, v, w) in &edges {
        if dist[u] != i32::MAX && dist[u] + w < dist[v] {
            dist[v] = dist[u] + w;
        }
    }
}
// Check for negative cycle
for &(u, v, w) in &edges {
    if dist[u] != i32::MAX && dist[u] + w < dist[v] {
        return true; // Negative cycle detected
    }
}
return false;

medium

A. The outer loop should run graph.len() - 1 times, not graph.len() times.

B. The distance vector is not initialized properly.

C. The negative cycle check should be inside the outer loop.

D. Edges should be relaxed in reverse order.

Solution

1. Step 1: Understand Bellman-Ford iteration count

   Bellman-Ford requires relaxing edges exactly |V| - 1 times (where |V| is number of vertices) to find shortest paths. Running it |V| times can cause incorrect behavior.

2. Step 2: Identify the bug in loop count

   The code runs the outer loop graph.len() times (equal to |V|), which is one too many. This can cause false detection of negative cycles.

3. Final Answer:

   The outer loop should run graph.len() - 1 times, not graph.len() times. -> Option A

4. Quick Check:

   Relax edges |V|-1 times = A [OK]

Hint: Relax edges exactly vertices minus one times [OK]

Common Mistakes:

• Running relaxation too many times
• Checking negative cycle inside main loop
• Incorrect distance initialization

5. You have a graph with 4 vertices and edges:
[(0, 1, 1), (1, 2, -1), (2, 3, -1), (3, 1, -1)]. Using Bellman-Ford starting from vertex 0, what will the algorithm detect?

hard

A. No negative cycle, shortest paths found.

B. Algorithm will run infinitely without detection.

C. Negative cycle detected involving vertices 1, 2, and 3.

D. Only positive weight cycles detected.

Solution

1. Step 1: Analyze the cycle formed by edges

   The edges (1->2, -1), (2->3, -1), and (3->1, -1) form a cycle with total weight -3, which is negative.

2. Step 2: Bellman-Ford detects negative cycles reachable from source

   Since this negative cycle is reachable from vertex 0 via edge (0->1), Bellman-Ford will detect it during the negative cycle check.

3. Final Answer:

   Negative cycle detected involving vertices 1, 2, and 3. -> Option C

4. Quick Check:

   Negative cycle in reachable cycle = C [OK]

Hint: Check cycles reachable from source for negative sum [OK]

Common Mistakes:

• Ignoring negative cycle presence
• Assuming algorithm runs infinitely
• Thinking only positive cycles exist