Bellman Ford Algorithm Negative Weights in DSA Rust - Build from Scratch

Bellman Ford Algorithm Negative Weights

📖 Scenario: You are working on a navigation system that needs to find the shortest path between cities. Some roads have tolls that can be negative due to discounts. You want to use the Bellman Ford algorithm to find the shortest paths even with these negative weights.

🎯 Goal: Build a Rust program that uses the Bellman Ford algorithm to find shortest distances from a start city to all other cities in a graph with possible negative edge weights.

📋 What You'll Learn

Create a vector of edges representing the graph with exact edges and weights

Create a vector called distances initialized with i32::MAX except the start vertex

Implement the Bellman Ford relaxation loop exactly as specified

Print the final distances vector after running the algorithm

💡 Why This Matters

🌍 Real World

Navigation systems and routing algorithms often need to handle roads or paths with negative costs, such as discounts or rebates. Bellman Ford helps find shortest paths in such cases.

💼 Career

Understanding Bellman Ford is important for software engineers working on graph algorithms, network routing, and optimization problems where negative weights can occur.

1

Create the graph edges

Create a vector called edges of tuples (usize, usize, i32) representing directed edges with weights. Add these exact edges: (0, 1, 4), (0, 2, 5), (1, 2, -3), (2, 3, 4), (3, 1, 6).

DSA Rust

# Create the vector edges with the given tuples
# Your code here

Hint

Use let edges: Vec<(usize, usize, i32)> = vec![ ... ]; with the exact tuples inside.

2

Initialize distances vector

Add a mutable vector called distances of type Vec with length 4. Initialize all values to i32::MAX except the start vertex 0 which should be set to 0.

DSA Rust

fn main() {
    let edges: Vec = vec![(0, 1, 4), (0, 2, 5), (1, 2, -3), (2, 3, 4), (3, 1, 6)];
    // Initialize distances vector
    # Your code here
}

Hint

Use vec![i32::MAX; 4] to create the vector and then set distances[0] = 0.

3

Implement Bellman Ford relaxation loop

Add a for loop that runs 3 times (number of vertices minus 1). Inside it, add a for loop over edges.iter(). For each edge (u, v, w), if distances[u] != i32::MAX and distances[u] + w < distances[v], update distances[v] to distances[u] + w.

DSA Rust

fn main() {
    let edges: Vec = vec![(0, 1, 4), (0, 2, 5), (1, 2, -3), (2, 3, 4), (3, 1, 6)];
    let mut distances: Vec = vec![i32::MAX; 4];
    distances[0] = 0;
    // Bellman Ford relaxation loop
    # Your code here
}

Hint

Use nested loops: outer for _ in 0..3 and inner for &(u, v, w) in edges.iter(). Use the if condition to relax edges.

4

Print the final distances vector

Add a println! statement to print the distances vector after the Bellman Ford algorithm finishes.

DSA Rust

fn main() {
    let edges: Vec = vec![(0, 1, 4), (0, 2, 5), (1, 2, -3), (2, 3, 4), (3, 1, 6)];
    let mut distances: Vec = vec![i32::MAX; 4];
    distances[0] = 0;

    for _ in 0..3 {
        for &(u, v, w) in edges.iter() {
            if distances[u] != i32::MAX && distances[u] + w < distances[v] {
                distances[v] = distances[u] + w;
            }
        }
    }
    // Print distances vector
    # Your code here
}

Hint

Use println!("{:?}", distances); to print the vector.

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