Bellman Ford Algorithm Negative Weights in DSA Rust - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the distance vector with infinity except the source vertex.

DSA Rust

let mut dist = vec![[1]; graph.len()];
dist[source] = 0;

Drag options to blanks, or click blank then click option'

A0

B-1

Cusize::MAX

DNone

Attempts:

3 left

💡 Hint

Common Mistakes

Using 0 for all distances which makes all nodes appear reachable immediately.

Using -1 which is invalid for usize type.

We initialize distances to the maximum usize value to represent infinity, except the source which is zero.

2fill in blank

medium

Complete the code to relax edges inside the main loop of Bellman-Ford.

DSA Rust

for &(u, v, w) in edges.iter() {
    if dist[u] != usize::MAX && dist[u] [1] dist[v].saturating_sub(w) {
        dist[v] = dist[u].saturating_add(w);
    }
}

Drag options to blanks, or click blank then click option'

A==

B>

C<

D!=

Attempts:

3 left

💡 Hint

Common Mistakes

Using '<' in the wrong direction causing no updates.

Using '==' which prevents relaxation.

Relaxation happens if the current distance to u plus edge weight is less than the current distance to v.

3fill in blank

hard

Fix the error in the negative cycle detection loop condition.

DSA Rust

for &(u, v, w) in edges.iter() {
    if dist[u] != usize::MAX && dist[u] [1] dist[v].saturating_sub(w) {
        return true; // Negative cycle detected
    }
}

Drag options to blanks, or click blank then click option'

A>=

B<

C==

D>

Attempts:

3 left

💡 Hint

Common Mistakes

Using '>=' or '==' which do not correctly detect negative cycles.

Using '<' which reverses the logic.

A negative cycle exists if we can still relax an edge, meaning dist[u] + w < dist[v].

4fill in blank

hard

Fill both blanks to complete the main relaxation loop and the iteration count.

DSA Rust

for _ in 0..[1] {
    for &(u, v, w) in edges.iter() {
        if dist[u] != usize::MAX && dist[u] [2] dist[v].saturating_sub(w) {
            dist[v] = dist[u].saturating_add(w);
        }
    }
}

Drag options to blanks, or click blank then click option'

Agraph.len() - 1

Bgraph.len()

C<

D>

Attempts:

3 left

💡 Hint

Common Mistakes

Using graph.len() instead of graph.len() - 1 for iterations.

Using '>' instead of '<' in relaxation condition.

The Bellman-Ford algorithm relaxes edges |V|-1 times, and relaxation happens if dist[u] + w < dist[v].

5fill in blank

hard

Fill all three blanks to complete the function signature, return type, and negative cycle detection.

DSA Rust

fn bellman_ford(graph: &Vec<Vec<(usize, i32)>>, source: usize) -> (Vec<i32>, bool) {
    let mut dist = vec![[1]; graph.len()];
    dist[source] = 0;
    let mut edges = Vec::new();
    for u in 0..graph.len() {
        for &(v, w) in &graph[u] {
            edges.push((u, v, w));
        }
    }
    for _ in 0..graph.len() - 1 {
        for &(u, v, w) in edges.iter() {
            if dist[u] != [2] && dist[u] + w < dist[v] {
                dist[v] = dist[u] + w;
            }
        }
    }
    for &(u, v, w) in edges.iter() {
        if dist[u] != [3] && dist[u] + w < dist[v] {
            return (dist, true);
        }
    }
    (dist, false)
}

Drag options to blanks, or click blank then click option'

Ai32::MAX

Bi32::MIN

Dusize::MAX

Attempts:

3 left

💡 Hint

Common Mistakes

Using usize::MAX for distances when weights are i32 causing type mismatch.

Using i32::MIN which is the smallest integer, not infinity.

Distances are initialized with i32::MAX to represent infinity. The checks compare dist[u] with i32::MAX to avoid overflow and detect negative cycles.

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