Shortest Path Visiting All Nodes - Practice Coding Problems

Shortest Path Visiting All Nodes - Problem

You're given an undirected, connected graph with n nodes labeled from 0 to n-1. The graph is represented as an adjacency list where graph[i] contains all nodes directly connected to node i.

Your goal is to find the shortest path that visits every node at least once. This is a variation of the famous Traveling Salesman Problem!

Key Points:

You can start and end at any node
You can revisit nodes multiple times
You can reuse edges
Return the minimum number of edges in such a path

For example, if you have nodes [0,1,2] connected as 0-1-2, you need at least 2 edges to visit all nodes: either 0→1→2 or 2→1→0.

Input & Output

example_1.py — Simple Triangle

$ Input: graph = [[1,2],[0,2],[0,1]]

› Output: 2

💡 Note: We have a triangle graph where all nodes are connected to each other. We can start at node 0, go to node 1 (1 edge), then go to node 2 (2 edges total). This visits all nodes in the minimum number of edges.

example_2.py — Linear Path

$ Input: graph = [[1],[0,2],[1]]

› Output: 2

💡 Note: This is a linear path: 0-1-2. To visit all nodes, we need exactly 2 edges. We can start at either end (0 or 2) and traverse to the other end, visiting all nodes along the way.

example_3.py — Single Node

$ Input: graph = [[]]

› Output: 0

💡 Note: With only one node and no edges, we're already visiting all nodes without moving anywhere. The shortest path length is 0.

Visualization

Tap to expand

Understanding the Visualization

Smart State Tracking

Use a binary code to represent which landmarks you've visited - like a digital passport stamp

Systematic Exploration

Start from every landmark simultaneously, exploring layer by layer

Avoid Redundancy

Never revisit the same (location, visit-history) combination

First Complete Tour

The first time you visit all landmarks is guaranteed to be optimal

Key Takeaway

🎯 Key Insight: By combining BFS (for shortest path guarantee) with bitmask state representation (for efficient visit tracking), we solve this complex graph problem optimally without exploring redundant paths.

Time & Space Complexity

Time Complexity

⏱️

O(n² × 2ⁿ)

We have n × 2^n possible states (n nodes × 2^n bitmasks), and for each state we check up to n neighbors

⚠ Quadratic Growth

Space Complexity

O(n × 2ⁿ)

We store up to n × 2^n states in our visited set and BFS queue

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 12
0 ≤ graph[i].length < n
graph[i] does not contain i
If graph[a] contains b, then graph[b] contains a
The input graph is always connected

Asked in

G Google 35 a Amazon 28 ⊞ Microsoft 22 f Meta 18

The optimal solution uses BFS with bitmask dynamic programming. We represent each state as (current_node, visited_bitmask) and use BFS to find the shortest path to a state where all nodes are visited. The key insight is using bitmasks to efficiently represent and compare sets of visited nodes, achieving O(n² × 2ⁿ) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Paths)	O(n! × n)	O(n)	Try all possible paths from each starting node using DFS with backtracking
BFS with Bitmask (Optimal)	O(n² × 2ⁿ)	O(n × 2ⁿ)	Use BFS with bitmasks to track visited nodes efficiently in a single pass

Brute Force (Try All Paths) — Algorithm Steps

Try each node as a starting point
Use DFS to explore all possible paths from that starting node
For each path, track which nodes have been visited
When all nodes are visited, record the path length
Backtrack and try other paths
Return the minimum path length found across all starting points

Visualization

Tap to expand

Step-by-Step Walkthrough

Choose Starting Node

Try each node as a potential starting point

DFS Exploration

Use depth-first search to explore all possible paths

Track Visited

Maintain set of visited nodes for each path

Check Complete

When all nodes visited, record path length

Backtrack

Return and try other paths

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>

int minPath = INT_MAX;

void dfs(int** graph, int* graphColSize, int n, int current, bool* visited, int visitedCount, int pathLength) {
    if (visitedCount == n) {
        if (pathLength < minPath) {
            minPath = pathLength;
        }
        return;
    }
    
    if (pathLength >= minPath) return;
    
    for (int i = 0; i < graphColSize[current]; i++) {
        int neighbor = graph[current][i];
        bool wasVisited = visited[neighbor];
        int newCount = visitedCount;
        
        if (!visited[neighbor]) {
            visited[neighbor] = true;
            newCount++;
        }
        
        dfs(graph, graphColSize, n, neighbor, visited, newCount, pathLength + 1);
        
        if (!wasVisited) {
            visited[neighbor] = false;
        }
    }
}

int shortestPathLength(int** graph, int graphSize, int* graphColSize) {
    if (graphSize == 1) return 0;
    
    minPath = INT_MAX;
    
    for (int start = 0; start < graphSize; start++) {
        bool* visited = calloc(graphSize, sizeof(bool));
        visited[start] = true;
        dfs(graph, graphColSize, graphSize, start, visited, 1, 0);
        free(visited);
    }
    
    return minPath;
}

int main() {
    // Parse input and solve
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

We try all n! possible permutations of visiting nodes, and each path can be up to n nodes long

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion depth and visited array storage

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 12
0 ≤ graph[i].length < n
graph[i] does not contain i
If graph[a] contains b, then graph[b] contains a
The input graph is always connected

38.0K Views

Medium Frequency

~25 min Avg. Time

1.5K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Paths) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler