Bridges in Graph Tarjan's Algorithm in DSA C++ - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the discovery time for the current node.

DSA C++

disc[u] = [1];
low[u] = time;
time++;

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

A0

Bu

C-1

Dtime

Attempts:

3 left

💡 Hint

Common Mistakes

Setting discovery time to node index instead of time.

Initializing discovery time to zero or -1 incorrectly.

The discovery time for node u is set to the current time counter before incrementing it.

2fill in blank

medium

Complete the code to update the low value of the current node after visiting a neighbor.

DSA C++

low[u] = std::min(low[u], [1]);

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

Alow[v]

Bdisc[v]

Ctime

Du

Attempts:

3 left

💡 Hint

Common Mistakes

Using discovery time of neighbor instead of low value.

Using the current time or node index incorrectly.

The low value of u is updated to the minimum between its current low and the low value of neighbor v.

3fill in blank

hard

Fix the error in the condition that checks if an edge is a bridge.

DSA C++

if (low[v] [1] disc[u]) {
    bridges.push_back({u, v});
}

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

A<=

B<

C>

D>=

Attempts:

3 left

💡 Hint

Common Mistakes

Using <= or < instead of > in the condition.

Confusing the order of comparison.

An edge (u, v) is a bridge if low[v] > disc[u], meaning v cannot reach an ancestor of u.

4fill in blank

hard

Fill both blanks to correctly skip the parent node and update low value for back edges.

DSA C++

for (int v : adj[u]) {
    if (v == [1]) continue;
    if (disc[v] != -1) {
        low[u] = std::min(low[u], [2]);
    }
}

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

Aparent

Bdisc[v]

Clow[v]

Dtime

Attempts:

3 left

💡 Hint

Common Mistakes

Not skipping the parent node causing incorrect cycles.

Using low[v] instead of disc[v] for back edge updates.

We skip the parent node to avoid trivial cycles, and update low[u] with the discovery time of v for back edges.

5fill in blank

hard

Fill all three blanks to complete the DFS function header and recursive call with correct parameters.

DSA C++

void dfs(int [1], int [2], std::vector<int>& disc, std::vector<int>& low, std::vector<std::vector<int>>& adj, std::vector<std::pair<int,int>>& bridges, int& time) {
    disc[u] = time;
    low[u] = time;
    time++;
    for (int v : adj[u]) {
        if (disc[v] == -1) {
            dfs([3], u, disc, low, adj, bridges, time);
            low[u] = std::min(low[u], low[v]);
            if (low[v] > disc[u]) {
                bridges.push_back({u, v});
            }
        } else if (v != parent) {
            low[u] = std::min(low[u], disc[v]);
        }
    }
}

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

Au

Bparent

Cv

Dtime

Attempts:

3 left

💡 Hint

Common Mistakes

Swapping parameter order in function or recursive call.

Using incorrect variable names in recursive call.

The DFS function takes current node u and its parent. The recursive call explores neighbor v with u as parent.

Practice

1. What is the main purpose of Tarjan's algorithm when finding bridges in a graph?

easy

A. To detect cycles in a graph

B. To find the shortest path between two nodes

C. To find edges that, if removed, increase the number of connected components

D. To count the total number of edges in the graph

Solution

1. Step 1: Understand the definition of a bridge

   A bridge is an edge that, when removed, increases the number of connected components in the graph.

2. Step 2: Relate Tarjan's algorithm to bridges

   Tarjan's algorithm efficiently finds such edges by using DFS and tracking discovery and low times.

3. Final Answer:

   To find edges that, if removed, increase the number of connected components -> Option C

4. Quick Check:

   Bridges = edges increasing components when removed [OK]

Hint: Bridges disconnect graph if removed [OK]

Common Mistakes:

• Confusing bridges with cycles
• Thinking it finds shortest paths
• Assuming it counts edges only

2. Which of the following is the correct way to declare the discovery time array in C++ for Tarjan's bridge-finding algorithm on a graph with n vertices?

easy

A. int disc[n];

B. vector<int> disc(n, -1);

C. int disc = new int[n];

D. int disc[] = new int();

Solution

1. Step 1: Understand C++ array and vector declarations

   Static arrays like int disc[n]; are not standard in C++ (unless n is a constant). Using vector<int> is safer and dynamic.

2. Step 2: Identify correct initialization for discovery times

   Initializing with -1 indicates unvisited nodes, which is common practice.

3. Final Answer:

   vector<int> disc(n, -1); -> Option B

4. Quick Check:

   Use vector with size and initial value [OK]

Hint: Use vector<int> with size and init value [OK]

Common Mistakes:

• Using variable-length arrays (not standard C++)
• Incorrect pointer syntax
• Not initializing discovery times

3. Consider the following C++ code snippet using Tarjan's algorithm to find bridges. What will be the output bridges for the given graph edges?

int n = 4;
vector<int> graph[4];
graph[0].push_back(1);
graph[1].push_back(0);
graph[1].push_back(2);
graph[2].push_back(1);
graph[2].push_back(3);
graph[3].push_back(2);
// After running Tarjan's bridge finder, which edges are bridges?
// Edges are represented as pairs (u, v) with u < v

medium

A. [(0, 1), (1, 2), (2, 3)]

B. [(0, 1), (1, 2)]

C. [(0, 1), (2, 3)]

D. []

Solution

1. Step 1: Visualize the graph structure

   The graph is a chain: 0 - 1 - 2 - 3 with bidirectional edges, forming a path with no cycles.

2. Step 2: Apply Tarjan's bridge finding logic

   In a path graph (a tree), every edge is a bridge because removing any disconnects the graph. Tarjan's DFS will detect all three edges where low[v] > disc[u] for each tree edge.

3. Final Answer:

   [(0, 1), (1, 2), (2, 3)] -> Option A

4. Quick Check:

   All edges in path are bridges [OK]

Hint: All edges in chain are bridges [OK]

Common Mistakes:

• Ignoring edge (0,1) as a bridge
• Assuming no bridges in chain
• Confusing bridge with cycle edges

4. Identify the bug in the following Tarjan's algorithm snippet for finding bridges:

void dfs(int u, int parent) {
  visited[u] = true;
  disc[u] = low[u] = time++;
  for (int v : graph[u]) {
    if (v == parent) continue;
    if (!visited[v]) {
      dfs(v, u);
      low[u] = min(low[u], low[v]);
      if (low[v] > disc[u])
        bridges.push_back({u, v});
    } else {
      low[u] = min(low[u], disc[v]);
    }
  }
}

medium

A. Missing initialization of time variable before DFS

B. Incorrect comparison in if condition for bridge detection

C. Not marking nodes as visited

D. Not checking for parent node in adjacency

Solution

1. Step 1: Review the DFS function variables

   The variable 'time' is used to assign discovery times but is not shown initialized before DFS calls.

2. Step 2: Understand impact of uninitialized time

   If 'time' is not initialized to 0 before DFS, discovery and low times will be incorrect, causing wrong bridge detection.

3. Final Answer:

   Missing initialization of time variable before DFS -> Option A

4. Quick Check:

   Initialize time = 0 before DFS [OK]

Hint: Initialize time counter before DFS call [OK]

Common Mistakes:

• Forgetting to initialize time
• Confusing low and disc arrays
• Not skipping parent node in DFS

5. Given a connected undirected graph with n vertices and m edges, how can Tarjan's algorithm be adapted to find all bridges efficiently, and what is its time complexity?

hard

A. Use Dijkstra's algorithm; time complexity O(m log n)

B. Use BFS with distance arrays; time complexity O(n^2)

C. Use DFS without low arrays; time complexity O(m^2)

D. Use DFS with discovery and low arrays; time complexity O(n + m)

Solution

1. Step 1: Describe Tarjan's algorithm adaptation

   Tarjan's algorithm uses DFS traversal, tracking discovery times and low values to detect bridges efficiently.

2. Step 2: Analyze time complexity

   Each vertex and edge is visited once during DFS, so the time complexity is O(n + m), where n is vertices and m is edges.

3. Final Answer:

   Use DFS with discovery and low arrays; time complexity O(n + m) -> Option D

4. Quick Check:

   DFS + low arrays = O(n + m) [OK]

Hint: DFS with low arrays runs in linear time [OK]

Common Mistakes:

• Using BFS which is not suitable here
• Ignoring low arrays in DFS
• Confusing with shortest path algorithms