Why Bellman Ford Algorithm Negative Weights in DSA Rust?

The Big Idea

What if some roads actually pay you to travel them? How do you find the cheapest path then?

The Scenario

Imagine you are planning a road trip across many cities. Some roads have tolls (positive costs), but some roads offer discounts or cashback (negative costs). You want to find the cheapest way to reach your destination.

Trying to calculate the cheapest path by hand, especially when some roads reduce your total cost, becomes confusing and error-prone.

The Problem

Manually checking every possible route and adjusting for discounts is slow and easy to mess up. Negative costs can cause loops that seem to reduce the cost forever, making it hard to know when to stop.

This manual method wastes time and can give wrong answers.

The Solution

The Bellman Ford algorithm smartly handles roads with negative costs. It systematically updates the cheapest cost to each city, even if some roads reduce the cost.

It also detects if there is a loop that keeps reducing the cost endlessly, so you know if the problem has no solution.

Before vs After

✗ Before

let mut costs = vec![std::i32::MAX; num_cities];
// Manually try all paths and update costs
// No clear stopping condition for negative loops

✓ After

for _ in 0..num_cities - 1 {
    for edge in &edges {
        if costs[edge.from] != std::i32::MAX && costs[edge.from] + edge.weight < costs[edge.to] {
            costs[edge.to] = costs[edge.from] + edge.weight;
        }
    }
}

What It Enables

You can reliably find the cheapest path even when some roads reduce your total cost, and know if no solution exists due to negative loops.

Real Life Example

In financial networks, some transactions might have fees (positive costs) or rebates (negative costs). Bellman Ford helps find the cheapest way to transfer money while detecting impossible infinite profit loops.

Key Takeaways

Manual path cost calculation fails with negative weights and loops.

Bellman Ford updates costs step-by-step to handle negative weights safely.

It detects negative cycles that make cost calculation impossible.

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