Why Shortest Path Is a Graph Problem Not a Tree Problem in DSA C# - See It Work

Why Shortest Path Is a Graph Problem Not a Tree Problem

📖 Scenario: Imagine you are planning a trip between cities connected by roads. Some roads form loops, and some cities connect in multiple ways. You want to find the shortest route from your home city to a destination city.This situation is like a graph, where cities are points (nodes) and roads are connections (edges). Unlike a tree, which has no loops and only one path between points, a graph can have many paths and loops.

🎯 Goal: You will create a simple graph with cities and roads, then show why finding the shortest path needs graph logic, not tree logic.This will help you understand why shortest path problems are solved using graphs.

📋 What You'll Learn

Create a graph using a dictionary where keys are city names and values are lists of connected cities.

Add a variable to hold the starting city.

Write code to find all possible paths from the start city to a target city using graph traversal.

Print the list of all paths found to show multiple routes exist.

💡 Why This Matters

🌍 Real World

Finding shortest routes in maps, network routing, and social connections all use graph shortest path algorithms.

💼 Career

Understanding graph traversal and shortest path is essential for software engineers working on navigation, logistics, and network systems.

1

Create the graph of cities and roads

Create a dictionary called cityGraph with these exact entries: "A" connected to ["B", "C"], "B" connected to ["A", "D", "E"], "C" connected to ["A", "F"], "D" connected to ["B"], "E" connected to ["B", "F"], and "F" connected to ["C", "E"].

DSA C#

# Create the cityGraph dictionary with the given connections
# Your code here

Hint

Use a Dictionary<string, List<string>> to represent the graph connections.

2

Set the starting city

Create a string variable called startCity and set it to "A".

DSA C#

using System.Collections.Generic;

Dictionary> cityGraph = new Dictionary>
{
    { "A", new List { "B", "C" } },
    { "B", new List { "A", "D", "E" } },
    { "C", new List { "A", "F" } },
    { "D", new List { "B" } },
    { "E", new List { "B", "F" } },
    { "F", new List { "C", "E" } }
};

// Set the starting city
# Your code here

Hint

Just create a string variable with the exact name and value.

3

Find all paths from start to target city

Write a method called FindAllPaths that takes cityGraph, a currentCity, a targetCity, a list called path, and a list of lists called allPaths. It should use recursion to find all paths from currentCity to targetCity without revisiting cities in path. Then call FindAllPaths(cityGraph, startCity, "F", new List<string>(), allPaths) to find all paths from startCity to "F".

DSA C#

using System.Collections.Generic;

Dictionary> cityGraph = new Dictionary>
{
    { "A", new List { "B", "C" } },
    { "B", new List { "A", "D", "E" } },
    { "C", new List { "A", "F" } },
    { "D", new List { "B" } },
    { "E", new List { "B", "F" } },
    { "F", new List { "C", "E" } }
};

string startCity = "A";

// Write the FindAllPaths method and call it to find all paths from startCity to "F"
# Your code here

Hint

Use recursion to explore neighbors and avoid revisiting cities already in the path.

4

Print all found paths

Write code to print each path in allPaths as a sequence of city names separated by " -> ".

DSA C#

using System;
using System.Collections.Generic;

Dictionary> cityGraph = new Dictionary>
{
    { "A", new List { "B", "C" } },
    { "B", new List { "A", "D", "E" } },
    { "C", new List { "A", "F" } },
    { "D", new List { "B" } },
    { "E", new List { "B", "F" } },
    { "F", new List { "C", "E" } }
};

string startCity = "A";

List> allPaths = new List>();

void FindAllPaths(Dictionary> graph, string currentCity, string targetCity, List path, List> allPaths)
{
    path.Add(currentCity);

    if (currentCity == targetCity)
    {
        allPaths.Add(new List(path));
    }
    else
    {
        foreach (string neighbor in graph[currentCity])
        {
            if (!path.Contains(neighbor))
            {
                FindAllPaths(graph, neighbor, targetCity, path, allPaths);
            }
        }
    }

    path.RemoveAt(path.Count - 1);
}

FindAllPaths(cityGraph, startCity, "F", new List(), allPaths);

// Print all paths found
# Your code here

Hint

Use a foreach loop to print each path with string.Join(" -> ", path).

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