Shortest Path in DAG Using Topological Order in DSA C - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of shortest path distances from source in DAG

What is the output of the following C code that finds shortest paths from source 0 in a DAG using topological order?

DSA C

#include <stdio.h>
#include <limits.h>
#define V 6

void shortestPath(int graph[V][V], int src) {
    int dist[V];
    int visited[V] = {0};
    int stack[V], top = -1;

    // Function to perform DFS and fill stack
    void dfs(int v) {
        visited[v] = 1;
        for (int i = 0; i < V; i++) {
            if (graph[v][i] != INT_MAX && !visited[i]) {
                dfs(i);
            }
        }
        stack[++top] = v;
    }

    for (int i = 0; i < V; i++) {
        if (!visited[i]) dfs(i);
    }

    for (int i = 0; i < V; i++) dist[i] = INT_MAX;
    dist[src] = 0;

    while (top >= 0) {
        int u = stack[top--];
        if (dist[u] != INT_MAX) {
            for (int v = 0; v < V; v++) {
                if (graph[u][v] != INT_MAX && dist[u] + graph[u][v] < dist[v]) {
                    dist[v] = dist[u] + graph[u][v];
                }
            }
        }
    }

    for (int i = 0; i < V; i++) {
        if (dist[i] == INT_MAX) printf("INF ");
        else printf("%d ", dist[i]);
    }
    printf("\n");
}

int main() {
    int graph[V][V] = {
        {INT_MAX, 5, 3, INT_MAX, INT_MAX, INT_MAX},
        {INT_MAX, INT_MAX, 2, 6, INT_MAX, INT_MAX},
        {INT_MAX, INT_MAX, INT_MAX, 7, 4, 2},
        {INT_MAX, INT_MAX, INT_MAX, INT_MAX, -1, 1},
        {INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX, -2},
        {INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX}
    };
    shortestPath(graph, 0);
    return 0;
}

A "0 5 3 10 7 5 "

B "0 5 3 9 6 4 "

C "0 INF INF INF INF INF "

D "0 5 3 13 7 5 "

💡 Hint

Trace the topological order and update distances step-by-step from source 0.

The code performs a DFS to get topological order, then relaxes edges in that order. The shortest distances from node 0 to others are: 0 (to itself), 5 (via edge 0->1), 3 (0->2), 10 (0->2->3), 7 (0->2->4), 5 (0->2->5).

🧠 Conceptual

intermediate

Why use topological order for shortest path in DAG?

Why is topological order used to find shortest paths in a Directed Acyclic Graph (DAG)?

A Because it sorts vertices by their distance from the source automatically.

B Because it ensures we process vertices only after all their predecessors, allowing correct distance updates without cycles.

C Because it detects cycles in the graph to avoid infinite loops.

D Because it finds the longest path in the graph first.

💡 Hint

Think about how processing order affects distance updates in graphs without cycles.

Topological order processes each vertex after all vertices that lead into it, so when we update distances, all shortest paths to predecessors are already known. This works only in DAGs because they have no cycles.

🔧 Debug

advanced

Identify the bug causing incorrect shortest path output

The following code attempts to find shortest paths in a DAG but produces wrong results. What is the bug?

DSA C

void shortestPath(int graph[V][V], int src) {
    int dist[V];
    int visited[V] = {0};
    int stack[V], top = -1;

    void dfs(int v) {
        visited[v] = 1;
        for (int i = 0; i < V; i++) {
            if (graph[v][i] != INT_MAX && !visited[i]) {
                dfs(i);
            }
        }
        stack[++top] = v;
    }

    for (int i = 0; i < V; i++) {
        if (!visited[i]) dfs(i);
    }

    for (int i = 0; i < V; i++) dist[i] = INT_MAX;
    dist[src] = 0;

    while (top >= 0) {
        int u = stack[top--];
        for (int v = 0; v < V; v++) {
            if (graph[u][v] != INT_MAX && dist[u] + graph[u][v] < dist[v]) {
                dist[v] = dist[u] + graph[u][v];
            }
        }
    }

    for (int i = 0; i < V; i++) {
        if (dist[i] == INT_MAX) printf("INF ");
        else printf("%d ", dist[i]);
    }
    printf("\n");
}

A The graph adjacency matrix uses 0 for no edge instead of INT_MAX.

B The DFS does not mark nodes as visited, causing infinite recursion.

C The stack is not used to store topological order.

D The code does not check if dist[u] is INT_MAX before relaxing edges, causing invalid additions.

💡 Hint

Check the relaxation step carefully for invalid distance updates.

If dist[u] is INT_MAX (meaning unreachable), adding graph[u][v] causes overflow or wrong values. The code must check dist[u] != INT_MAX before relaxing edges.

📝 Syntax

advanced

Identify the syntax error in the topological sort DFS function

Which option contains the syntax error in this DFS function used for topological sorting?

DSA C

void dfs(int v) {
    visited[v] = 1
    for (int i = 0; i < V; i++) {
        if (graph[v][i] != INT_MAX && !visited[i]) {
            dfs(i);
        }
    }
    stack[++top] = v;
}

A Missing braces around for loop body

B Incorrect increment operator in stack[++top]

C Missing semicolon after visited[v] = 1

D Missing return type for dfs function

💡 Hint

Look carefully at each line for missing punctuation.

The line 'visited[v] = 1' is missing a semicolon at the end, causing a syntax error.

🚀 Application

expert

Number of shortest paths from source to target in DAG

Given a DAG with weighted edges (all weights positive), how can you modify the shortest path algorithm using topological order to also count the number of distinct shortest paths from source to each vertex?

A Maintain a count array initialized with 0 except source=1; when relaxing edges, if a shorter path is found, update count[v] = count[u]; if equal path length found, add count[u] to count[v].

B Use a BFS instead of topological order and increment count for each visited node.

C Store all paths explicitly in a list and count them after shortest path calculation.

D Run the shortest path algorithm multiple times, each time removing edges used in previous shortest paths.

💡 Hint

Think about how to track number of ways while updating shortest distances.

By maintaining a count array, we track how many shortest paths reach each vertex. When a shorter path is found, reset count; when an equal path is found, add counts. This works efficiently with topological order.