Shortest Path in DAG Using Topological Order in DSA Rust - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the distance vector with infinity values.

DSA Rust

let mut dist = vec![[1]; n];

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

A0

B-1

Ci32::MAX

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Using 0 instead of infinity causes incorrect shortest path calculations.

Using negative values can cause logic errors.

We initialize distances with i32::MAX to represent infinity before relaxation.

2fill in blank

medium

Complete the code to set the source node distance to zero.

DSA Rust

dist[[1]] = 0;

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

Asource

B1

Cn

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Setting distance at wrong index.

Not initializing source distance to zero.

The source node distance is zero because it is the starting point.

3fill in blank

hard

Fix the error in the edge relaxation condition inside the loop.

DSA Rust

if dist[u] != i32::MAX && dist[v] [1] dist[u] + w {

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

A<

B>

C<=

D>=

Attempts:

3 left

💡 Hint

Common Mistakes

Using < instead of > reverses the logic and breaks shortest path calculation.

Not checking dist[u] != i32::MAX causes overflow.

We check if dist[u] + w is less than dist[v]. The operator > is used to compare dist[v] with dist[u] + w.

4fill in blank

hard

Fill both blanks to correctly update the distance of the adjacent node.

DSA Rust

dist[v] = dist[u] [1] [2];

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

A+

B-

C*

Dw

Attempts:

3 left

💡 Hint

Common Mistakes

Using subtraction or multiplication instead of addition.

Using wrong variable instead of edge weight.

We add the edge weight w to dist[u] to update dist[v].

5fill in blank

hard

Fill all three blanks to complete the loop that relaxes edges for each node in topological order.

DSA Rust

for &u in [1].iter() {
    if dist[u] != i32::MAX {
        for &(v, w) in [2][u].iter() {
            if dist[u] + w < dist[v] {
                dist[v] = dist[u] [3] w;
            }
        }
    }
}

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

Atopo_order

Bgraph

C+

Dedges

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong variable names for iteration or adjacency list.

Using wrong operator for updating distance.

We iterate over nodes in topo_order, access adjacency list graph[u], and update dist[v] by adding w.

Practice

1. What is the main advantage of using topological order to find the shortest path in a Directed Acyclic Graph (DAG)?

easy

A. It finds the longest path instead of the shortest.

B. It guarantees the graph has cycles.

C. It sorts vertices by their weights.

D. It allows processing vertices in a linear order without revisiting nodes.

Solution

1. Step 1: Understand topological order in DAG

   Topological order arranges vertices so all edges go from earlier to later vertices, ensuring no cycles.

2. Step 2: Use topological order for shortest path

   Processing vertices in this order allows updating shortest paths without revisiting nodes, making the algorithm efficient.

3. Final Answer:

   It allows processing vertices in a linear order without revisiting nodes. -> Option D

4. Quick Check:

   Topological order = linear processing [OK]

Hint: Topological order processes nodes once in DAG [OK]

Common Mistakes:

• Thinking DAG has cycles
• Confusing topological order with sorting by weights
• Assuming it finds longest path

2. Which Rust code snippet correctly initializes a vector to store shortest distances with infinity for all vertices except the source (index 0)?

easy

A. let dist = vec![i32::MAX; n]; dist[0] = 0;

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

C. let dist = vec![None; n]; dist[0] = Some(0);

D. let dist = vec![0; n];

Solution

1. Step 1: Initialize distances with maximum value

   Using vec![i32::MAX; n] sets all distances to infinity (max int), representing unknown paths.

2. Step 2: Set source distance to zero

   dist[0] = 0 sets the source vertex distance to zero, as it is the start point.

3. Final Answer:

   let dist = vec![i32::MAX; n]; dist[0] = 0; -> Option A

4. Quick Check:

   Initialize with max, source zero [OK]

Hint: Use vec![i32::MAX; n] and set source to 0 [OK]

Common Mistakes:

• Setting source distance to max instead of zero
• Using zero for all distances initially
• Using Option types unnecessarily

3. Given the following Rust code snippet for shortest path in a DAG, what is the final distance vector printed?

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

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

let topo_order = vec![0, 1, 2, 3];

for &u in &topo_order {
  for &(src, dst, w) in &edges {
    if src == u && dist[u] != i32::MAX && dist[u] + w < dist[dst] {
      dist[dst] = dist[u] + w;
    }
  }
}

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

medium

A. [0, 1, 4, 7]

B. [0, 1, 3, 6]

C. [0, 4, 6, 9]

D. [i32::MAX, i32::MAX, i32::MAX, i32::MAX]

Solution

1. Step 1: Initialize distances and process vertex 0

   dist = [0, MAX, MAX, MAX]. From 0: update dist[1] = 0+1=1, dist[2] = 0+4=4.

2. Step 2: Process vertex 1 and 2

   From 1: dist[2] = min(4, 1+2=3) = 3, dist[3] = 1+6=7. From 2: dist[3] = min(7, 3+3=6) = 6.

3. Step 3: Process vertex 3

   No outgoing edges, distances remain.

4. Final Answer:

   [0, 1, 3, 6] -> Option B

5. Quick Check:

   Relax edges in topo order = [0,1,3,6] [OK]

Hint: Relax edges in topological order to update distances [OK]

Common Mistakes:

• Not updating dist[2] to 3 via vertex 1
• Ignoring better path to dist[3]
• Printing distances before updates

4. Identify the bug in this Rust code snippet for shortest path in a DAG using topological order:

let n = 3;
let edges = vec![(0, 1, 5), (1, 2, 10)];
let mut dist = vec![i32::MAX; n];
dist[0] = 0;
let topo_order = vec![0, 1, 2];

for u in topo_order {
  for &(src, dst, w) in &edges {
    if src == u && dist[dst] != i32::MAX && dist[u] + w < dist[dst] {
      dist[dst] = dist[u] + w;
    }
}
}
println!("{:?}", dist);

medium

A. The condition 'dist[dst] != i32::MAX' prevents updating distances correctly.

B. The topological order vector is incorrect.

C. The initial distance vector should be zeros.

D. Edges are not represented as tuples.

Solution

1. Step 1: Analyze the if condition in edge relaxation

   The condition 'dist[dst] != i32::MAX' wrongly blocks updating dist[dst] if it is still infinity, so no update happens initially.

2. Step 2: Correct the condition to allow updates

   Remove 'dist[dst] != i32::MAX' so that if dist[u] + w is less, dist[dst] updates even if dist[dst] was infinity.

3. Final Answer:

   The condition 'dist[dst] != i32::MAX' prevents updating distances correctly. -> Option A

4. Quick Check:

   Wrong condition blocks updates [OK]

Hint: Allow updates even if dist[dst] is infinity [OK]

Common Mistakes:

• Adding unnecessary condition on dist[dst]
• Incorrect topological order
• Initializing distances with zeros

5. You have a DAG with 5 vertices and edges with weights: (0->1:2), (0->2:3), (1->3:4), (2->3:1), (3->4:5). Using topological order [0,1,2,3,4], what is the shortest path distance from vertex 0 to vertex 4?

hard

A. 11

B. 10

C. 9

D. 8

Solution

1. Step 1: Initialize distances and process vertex 0

   dist = [0, MAX, MAX, MAX, MAX]. From 0: dist[1] = 2, dist[2] = 3.

2. Step 2: Process vertex 1 and 2

   From 1: dist[3] = 2 + 4 = 6. From 2: dist[3] = min(6, 3 + 1 = 4) = 4.

3. Step 3: Process vertex 3 and 4

   From 3: dist[4] = 4 + 5 = 9. Vertex 4 has no outgoing edges.

4. Final Answer:

   9 -> Option C

5. Quick Check:

   Shortest path 0->2->3->4 = 9 [OK]

Hint: Relax edges in topo order, pick minimum sums [OK]

Common Mistakes:

• Choosing path 0->1->3->4 without checking shorter 0->2->3->4
• Adding weights incorrectly
• Ignoring topological order