Why Shortest Path Is a Graph Problem Not a Tree Problem in DSA C# - Test Your Knowledge

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a graph using adjacency list.

DSA C#

Dictionary<int, List<int>> graph = new Dictionary<int, List<int>>();
graph.Add(1, new List<int> { [1] });

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

A1

B2, 3

C3

D2

Attempts:

3 left

💡 Hint

Common Mistakes

Adding only one neighbor when multiple neighbors exist.

Adding the node itself as its neighbor.

The adjacency list for node 1 should contain its neighbors. Here, nodes 2 and 3 are neighbors, so we add both.

2fill in blank

medium

Complete the code to check if a node exists in the graph.

DSA C#

if (graph.[1](3)) {
    Console.WriteLine("Node 3 exists");
}

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

AContainsKey

BContainsValue

CContains

DHasKey

Attempts:

3 left

💡 Hint

Common Mistakes

Using ContainsValue which checks values, not keys.

Using a non-existent method like HasKey.

ContainsKey checks if the dictionary has a specific key, which is the node here.

3fill in blank

hard

Fix the error in the code to add an edge between nodes 2 and 3.

DSA C#

graph[2].Add([1]);

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

A2

B1

C3

D4

Attempts:

3 left

💡 Hint

Common Mistakes

Adding the same node number (2) instead of the neighbor.

Adding a node not connected to 2.

To add an edge from node 2 to node 3, we add 3 to the adjacency list of node 2.

4fill in blank

hard

Fill both blanks to create a method that returns true if a path exists between two nodes.

DSA C#

bool PathExists(int start, int end) {
    var visited = new HashSet<int>();
    var queue = new Queue<int>();
    queue.Enqueue(start);
    while (queue.Count > 0) {
        int current = queue.Dequeue();
        if (current [1] end) return true;
        visited.Add(current);
        foreach (var neighbor in graph[current]) {
            if (!visited.Contains(neighbor)) {
                queue.[2](neighbor);
            }
        }
    }
    return false;
}

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

A==

BEnqueue

C!=

DAdd

Attempts:

3 left

💡 Hint

Common Mistakes

Using '!=' instead of '==' in the if condition.

Using 'Add' instead of 'Enqueue' for the queue.

We check if current equals end to find the path. We add neighbors to the queue using Enqueue.

5fill in blank

hard

Fill all three blanks to create a dictionary comprehension that maps nodes to their degrees (number of neighbors).

DSA C#

var degrees = new Dictionary<int, int>();
foreach (var node in graph.Keys) {
    degrees[[1]] = graph[[2]].[3];
}

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

Anode

CCount

DLength

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'Length' which is not valid for List in C#.

Using different variables instead of 'node'.

We use 'node' as the key and index, and 'Count' to get the number of neighbors in the list.

Practice

1. Why is finding the shortest path usually considered a graph problem rather than a tree problem?

easy

A. Because graphs can have cycles and multiple paths between nodes, unlike trees

B. Because trees always have weighted edges

C. Because shortest path algorithms only work on trees

D. Because trees do not have nodes

Solution

1. Step 1: Understand the structure of trees and graphs

   Trees are a special type of graph with no cycles and exactly one path between any two nodes. Graphs can have cycles and multiple paths between nodes.

2. Step 2: Relate shortest path to multiple paths

   Shortest path problems require checking multiple possible routes to find the minimum distance. This is only possible in graphs with cycles or multiple paths, not in trees where only one path exists.

3. Final Answer:

   Because graphs can have cycles and multiple paths between nodes, unlike trees -> Option A

4. Quick Check:

   Multiple paths = Graph problem [OK]

Hint: Shortest path needs multiple routes, trees have only one [OK]

Common Mistakes:

• Thinking trees can have cycles
• Assuming shortest path applies only to trees
• Confusing weighted edges with graph structure

2. Which of the following C# code snippets correctly declares a graph node with adjacency list for shortest path algorithms?

easy

A. public class Node { public int Value; public int Weight; }

B. public class Node { public int Value; public Node Next; }

C. public class Node { public int Value; public Node Left; public Node Right; }

D. public class Node { public int Value; public List<Node> Neighbors = new List<Node>(); }

Solution

1. Step 1: Identify graph node structure

   A graph node for shortest path needs to store neighbors as a list to represent edges to multiple nodes.

2. Step 2: Check each option

   public class Node { public int Value; public List<Node> Neighbors = new List<Node>(); } uses List<Node> Neighbors, suitable for graph adjacency. public class Node { public int Value; public Node Next; } and C represent linked list and binary tree nodes respectively. public class Node { public int Value; public int Weight; } lacks neighbor references.

3. Final Answer:

   public class Node { public int Value; public List<Node> Neighbors = new List<Node>(); } -> Option D

4. Quick Check:

   Adjacency list uses List<Node> [OK]

Hint: Graph nodes need neighbor lists, not single links [OK]

Common Mistakes:

• Using single 'Next' pointer like linked list
• Confusing tree left/right with graph neighbors
• Ignoring adjacency list for multiple edges

3. Consider the following C# code snippet for a graph with weighted edges. What will be the output of the shortest path from node 0 to node 3?

var graph = new Dictionary>
{
  {0, new List<(int, int)>{(1, 4), (2, 1)}},
  {1, new List<(int, int)>{(3, 1)}},
  {2, new List<(int, int)>{(1, 2), (3, 5)}},
  {3, new List<(int, int)>{}}
};
// Using Dijkstra's algorithm, shortest distance from 0 to 3 is?

medium

A. 6

B. 4

C. 5

D. 7

Solution

1. Step 1: Analyze paths from node 0 to 3

   Possible paths: 0->1->3 with cost 4+1=5, 0->2->1->3 with cost 1+2+1=4, 0->2->3 with cost 1+5=6.

2. Step 2: Find shortest path cost

   Check path costs: 0->1->3 = 5, 0->2->1->3 = 4, 0->2->3 = 6. The shortest is 4 via 0->2->1->3.

3. Final Answer:

   4 -> Option B

4. Quick Check:

   Shortest path cost = 4 [OK]

Hint: Check all paths and sum weights, pick smallest [OK]

Common Mistakes:

• Ignoring intermediate nodes in path
• Adding wrong edge weights
• Choosing direct but costlier path

4. The following C# code attempts to find the shortest path in a graph but has a bug. What is the main issue?

var graph = new Dictionary
{
  {0, new List<int>{1, 2}},
  {1, new List<int>{3}},
  {2, new List<int>{3}},
  {3, new List<int>()}
};

var visited = new HashSet<int>();
var queue = new Queue<int>();
queue.Enqueue(0);

while(queue.Count > 0)
{
  var node = queue.Dequeue();
  if(node == 3) break;
  foreach(var neighbor in graph[node])
  {
    if(!visited.Contains(neighbor))
    {
      queue.Enqueue(neighbor);
    }
  }
  visited.Add(node);
}

medium

A. Graph edges are missing weights, so shortest path can't be found

B. Queue is used instead of stack, so traversal is incorrect

C. Visited nodes are added after enqueueing neighbors, causing repeated visits

D. Visited nodes are never added, causing infinite loop

Solution

1. Step 1: Understand visited node handling

   Visited nodes should be marked before enqueueing neighbors to avoid adding duplicates to the queue.

2. Step 2: Identify bug in code

   Here, visited.Add(node) is called after enqueueing neighbors, so neighbors may be enqueued multiple times before node is marked visited.

3. Final Answer:

   Visited nodes are added after enqueueing neighbors, causing repeated visits -> Option C

4. Quick Check:

   Mark visited before enqueue [OK]

Hint: Add to visited before enqueueing neighbors [OK]

Common Mistakes:

• Adding visited after enqueueing neighbors
• Confusing queue with stack for BFS
• Ignoring visited set causing infinite loops

5. You have a weighted graph with cycles. Why can't you use a simple tree traversal algorithm to find the shortest path between two nodes?

hard

A. Because tree traversal assumes only one path exists, missing shorter paths in cycles

B. Because tree traversal algorithms do not work on weighted edges

C. Because trees do not allow visiting nodes more than once

D. Because shortest path requires sorting nodes by value

Solution

1. Step 1: Understand tree traversal assumptions

   Tree traversal assumes a single unique path between nodes, no cycles, so it does not check alternative routes.

2. Step 2: Explain why cycles affect shortest path

   In graphs with cycles, multiple paths exist. Simple tree traversal misses shorter paths that involve cycles or alternate routes.

3. Final Answer:

   Because tree traversal assumes only one path exists, missing shorter paths in cycles -> Option A

4. Quick Check:

   Multiple paths need graph algorithms [OK]

Hint: Cycles need graph methods, trees have single paths only [OK]

Common Mistakes:

• Thinking tree traversal handles cycles
• Assuming weights prevent tree traversal
• Confusing node sorting with path finding