Hamiltonian Path Finder - Problem

A Hamiltonian path is a path in a graph that visits every vertex exactly once. Given an undirected graph represented as an adjacency list, determine if a Hamiltonian path exists.

If a Hamiltonian path exists, return the path as an array of vertices. If no such path exists, return an empty array.

Note: The graph is represented as an adjacency list where graph[i] contains all vertices adjacent to vertex i. Vertices are numbered from 0 to n-1.

Input & Output

Example 1 — Simple Path

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

› Output: [1,0,2]

💡 Note: Graph has vertices 0,1,2 with edges 0-1 and 1-2. Path 1→0→2 visits all vertices exactly once.

Example 2 — Triangle Graph

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

› Output: [0,1,2]

💡 Note: Complete triangle where every vertex connects to every other. Multiple Hamiltonian paths exist, return any one.

Example 3 — No Path Exists

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

› Output: []

💡 Note: Vertex 2 is isolated (no connections), so no path can visit all vertices.

Constraints

1 ≤ graph.length ≤ 15
0 ≤ graph[i].length ≤ graph.length
graph[i][j] is a valid vertex index
graph[i] does not contain duplicate vertices
The graph is undirected: if j is in graph[i], then i is in graph[j]

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 18 a Amazon 15 f Meta 12

The key insight is using backtracking to systematically explore all possible paths while pruning invalid branches early. The optimal approach uses recursive depth-first search with a visited array, trying each vertex as a starting point. Time: O(n!), Space: O(n)

Common Approaches

✓ Backtracking with Pruning

⏱️ Time: O(n!) Space: O(n)

Build the path step by step using recursion. Mark vertices as visited, explore neighbors recursively, and backtrack when no valid continuation exists.

Try All Permutations

⏱️ Time: O(n! × n) Space: O(n)

Generate all n! permutations of vertices and check if each permutation represents a valid path by verifying consecutive vertices are connected in the graph.

Backtracking with Pruning — Algorithm Steps

Start from each vertex as potential starting point
Mark current vertex as visited
Recursively try each unvisited neighbor
If all vertices visited, return path; otherwise backtrack

Visualization

Tap to expand

Step-by-Step Walkthrough

Choose Start

Pick starting vertex, mark as visited

Explore Neighbors

Try each unvisited neighbor recursively

Backtrack

If stuck, unmark and try different path

Code -

solution.c — C

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

#define MAX_VERTICES 20

int graph[MAX_VERTICES][MAX_VERTICES];
int n;
int result[MAX_VERTICES];
bool found = false;

bool isConnected(int u, int v) {
    return graph[u][v] == 1;
}

void backtrack(int path[], bool visited[], int pos) {
    if (found) return;
    
    if (pos == n) {
        for (int i = 0; i < n; i++) {
            result[i] = path[i];
        }
        found = true;
        return;
    }
    
    int current = pos > 0 ? path[pos-1] : -1;
    for (int v = 0; v < n; v++) {
        if (!visited[v] && (current == -1 || isConnected(current, v))) {
            path[pos] = v;
            visited[v] = true;
            backtrack(path, visited, pos + 1);
            visited[v] = false;
            if (found) return;
        }
    }
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Initialize graph
    memset(graph, 0, sizeof(graph));
    n = 0;
    
    // Simple parsing - count vertices first
    char *ptr = line;
    while (*ptr) {
        if (*ptr == '[' && *(ptr+1) != '[') n++;
        ptr++;
    }
    
    // Parse adjacency list
    ptr = line + 1; // Skip first '['
    for (int i = 0; i < n; i++) {
        ptr++; // Skip '['
        int num;
        while (*ptr != ']') {
            if (sscanf(ptr, "%d", &num) == 1) {
                graph[i][num] = 1;
                while (*ptr != ',' && *ptr != ']') ptr++;
                if (*ptr == ',') ptr++;
            } else {
                ptr++;
            }
        }
        ptr++; // Skip ']'
        if (*ptr == ',') ptr++;
    }
    
    if (n == 0) {
        printf("[]\n");
        return 0;
    }
    if (n == 1) {
        printf("[0]\n");
        return 0;
    }
    
    int path[MAX_VERTICES];
    bool visited[MAX_VERTICES] = {false};
    
    backtrack(path, visited, 0);
    
    printf("[");
    if (found) {
        for (int i = 0; i < n; i++) {
            printf("%d", result[i]);
            if (i < n - 1) printf(",");
        }
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n!)

In worst case explores all possible paths, but pruning makes it much faster in practice

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth and visited array of size n

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~35 min Avg. Time

890 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

Hamiltonian Path Finder - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Backtracking with Pruning — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler