Graph Path Finder - Problem

Given an undirected graph represented as an adjacency list and two nodes start and end, find all possible paths between them.

Return a list containing:

All paths from start to end (as arrays of node values)
The shortest path (fewest nodes)
The longest path (most nodes)

Note: If multiple paths have the same length, return any one of them for shortest/longest.

Input & Output

Example 1 — Simple Path

$ Input: graph = {"1":[2,3], "2":[1,4], "3":[1,4], "4":[2,3]}, start = 1, end = 4

› Output: [[[1,2,4],[1,3,4]], [1,2,4], [1,2,4]]

💡 Note: Two paths exist from node 1 to 4: [1,2,4] and [1,3,4]. Both have length 3, so either can be shortest/longest.

Example 2 — Multiple Lengths

$ Input: graph = {"1":[2], "2":[1,3,4], "3":[2,4], "4":[2,3]}, start = 1, end = 4

› Output: [[[1,2,4],[1,2,3,4]], [1,2,4], [1,2,3,4]]

💡 Note: Path [1,2,4] has length 3, path [1,2,3,4] has length 4. Shortest is [1,2,4], longest is [1,2,3,4].

Example 3 — Same Start and End

$ Input: graph = {"1":[2], "2":[1]}, start = 1, end = 1

› Output: [[[1]], [1], [1]]

💡 Note: When start equals end, return single-node path [1] for all three results.

Constraints

1 ≤ number of nodes ≤ 20
Graph is undirected
Node values are positive integers
Graph may be disconnected

Visualization

Tap to expand

Asked in

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

The key insight is to use depth-first search with backtracking to systematically explore all possible paths between two nodes. We maintain a visited set to avoid cycles and track the shortest and longest paths during exploration. Best approach uses DFS with real-time tracking. Time: O(2^N), Space: O(N)

Common Approaches

✓ Depth-First Search with Backtracking

⏱️ Time: O(2^N) Space: O(N)

Recursively explore each neighbor of current node, maintaining a path and visited set. When we reach the end node, save the current path. Backtrack by removing the current node from visited set.

Optimized DFS with Early Tracking

⏱️ Time: O(2^N) Space: O(N)

Same DFS approach but maintain running shortest and longest paths as we discover new complete paths. This eliminates the need to compare all paths after collection.

Depth-First Search with Backtracking — Algorithm Steps

Start DFS from the start node
For each unvisited neighbor, add to path and mark visited
If neighbor is end node, save the complete path
Recursively explore neighbor's neighbors
Backtrack by unmarking current node as visited

Visualization

Tap to expand

Step-by-Step Walkthrough

Start DFS

Begin at start node, mark as visited

Explore Neighbors

Visit unvisited neighbors, add to current path

Found Path

When reaching end node, save complete path

Backtrack

Remove node from path and continue exploration

Compare Lengths

Find shortest and longest among all paths

Code -

solution.c — C

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

#define MAX_NODES 100
#define MAX_PATHS 1000
#define MAX_PATH_LENGTH 100

int adj[MAX_NODES][MAX_NODES];
int adjCount[MAX_NODES];
int allPaths[MAX_PATHS][MAX_PATH_LENGTH];
int pathLengths[MAX_PATHS];
int pathCount = 0;

void dfs(int current, int target, int* path, int pathLen, int* visited) {
    if (current == target) {
        for (int i = 0; i < pathLen; i++) {
            allPaths[pathCount][i] = path[i];
        }
        pathLengths[pathCount] = pathLen;
        pathCount++;
        return;
    }
    
    for (int i = 0; i < adjCount[current]; i++) {
        int neighbor = adj[current][i];
        if (!visited[neighbor]) {
            path[pathLen] = neighbor;
            visited[neighbor] = 1;
            dfs(neighbor, target, path, pathLen + 1, visited);
            visited[neighbor] = 0;
        }
    }
}

void solution(int start, int end) {
    if (start == end) {
        printf("[[[%d]],[[%d]],[[%d]]]\n", start, start, start);
        return;
    }
    
    pathCount = 0;
    int visited[MAX_NODES] = {0};
    int path[MAX_PATH_LENGTH];
    
    path[0] = start;
    visited[start] = 1;
    dfs(start, end, path, 1, visited);
    
    if (pathCount == 0) {
        printf("[[],[],[]]\n");
        return;
    }
    
    int shortestIdx = 0, longestIdx = 0;
    for (int i = 1; i < pathCount; i++) {
        if (pathLengths[i] < pathLengths[shortestIdx]) shortestIdx = i;
        if (pathLengths[i] > pathLengths[longestIdx]) longestIdx = i;
    }
    
    printf("[");
    // Print all paths
    printf("[");
    for (int i = 0; i < pathCount; i++) {
        printf("[");
        for (int j = 0; j < pathLengths[i]; j++) {
            printf("%d", allPaths[i][j]);
            if (j < pathLengths[i] - 1) printf(",");
        }
        printf("]");
        if (i < pathCount - 1) printf(",");
    }
    printf("],");
    
    // Print shortest path
    printf("[");
    for (int i = 0; i < pathLengths[shortestIdx]; i++) {
        printf("%d", allPaths[shortestIdx][i]);
        if (i < pathLengths[shortestIdx] - 1) printf(",");
    }
    printf("],");
    
    // Print longest path
    printf("[");
    for (int i = 0; i < pathLengths[longestIdx]; i++) {
        printf("%d", allPaths[longestIdx][i]);
        if (i < pathLengths[longestIdx] - 1) printf(",");
    }
    printf("]";
    
    printf("]\n");
}

int main() {
    // Simplified input parsing for demo
    int start, end;
    scanf("%d %d", &start, &end);
    solution(start, end);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^N)

In worst case (complete graph), we may explore all possible subsets of nodes

✓ Linear Growth

Space Complexity

O(N)

Recursion depth limited by number of nodes, plus visited set storage

✓ Linear Space

28.5K Views

Medium Frequency

~25 min Avg. Time

892 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

Graph Path Finder - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Depth-First Search with Backtracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler