Codestin Search App

Reconstruct Itinerary - Problem

Imagine you're a travel enthusiast who just returned from an amazing multi-city trip! You have a pile of airline tickets, but they're all mixed up. Your goal is to reconstruct your complete travel itinerary in the correct order.

You are given a list of airline tickets where tickets[i] = [from_i, to_i] represents the departure and arrival airports of one flight. All tickets belong to someone who started their journey from "JFK" airport.

Requirements:

The itinerary must begin with "JFK"
You must use all tickets exactly once
If multiple valid itineraries exist, return the one with the smallest lexicographical order
For example: ["JFK", "LGA"] comes before ["JFK", "LGB"]

Think of this as finding an Eulerian path in a directed graph where each ticket represents an edge!

Input & Output

example_1.py — Basic Case

$ Input: tickets = [["MUC","LHR"],["JFK","MUC"],["SFO","SJC"],["LHR","SFO"]]

› Output: ["JFK","MUC","LHR","SFO","SJC"]

💡 Note: Starting from JFK, we can only go to MUC. From MUC to LHR, LHR to SFO, and finally SFO to SJC. This uses all tickets exactly once.

example_2.py — Multiple Valid Paths

$ Input: tickets = [["JFK","SFO"],["JFK","ATL"],["SFO","ATL"],["ATL","JFK"],["ATL","SFO"]]

› Output: ["JFK","ATL","JFK","SFO","ATL","SFO"]

💡 Note: Multiple valid itineraries exist, but we choose the lexicographically smallest: JFK→ATL comes before JFK→SFO, so we start with ATL path.

example_3.py — Circular Route

$ Input: tickets = [["JFK","KUL"],["JFK","NRT"],["NRT","JFK"]]

› Output: ["JFK","NRT","JFK","KUL"]

💡 Note: We have two choices from JFK: KUL or NRT. Since we need to use all tickets, we must choose the path that allows us to return and use the remaining ticket.

Constraints

1 ≤ tickets.length ≤ 300
tickets[i].length == 2
from_i.length == 3
to_i.length == 3
from_i and to_i consist of uppercase English letters
All tickets belong to a man who departs from "JFK"
All tickets form at least one valid itinerary

Visualization

Tap to expand

Eulerian Path problem - traverse every edge exactly once• Use Hierholzer's Algorithm: DFS + remove edges + post-order recording• Sort destinations alphabetically to ensure lexicographical order• Backtrack when stuck and record nodes in reverse order⚡ Time: O(E log E) | Space: O(E)

Understanding the Visualization

Model as Graph

Each airport is a node, each ticket is a directed edge

Sort Destinations

For each airport, sort its destinations alphabetically

DFS with Edge Removal

Start from JFK, follow edges and remove them as we use tickets

Backtrack Strategy

When stuck, backtrack and record the current airport

Reverse Path

The recorded path is in reverse order, so flip it for the final answer

Key Takeaway

🎯 Key Insight: This is fundamentally an Eulerian path problem. By using Hierholzer's algorithm with DFS and careful edge removal, we can efficiently find the lexicographically smallest valid itinerary in O(E log E) time.

Asked in

G Google 45 a Amazon 38 f Facebook 32 ⊞ Microsoft 28 Apple 15

The optimal solution uses Hierholzer's algorithm with DFS and backtracking to find an Eulerian path. Build an adjacency list with sorted destinations, traverse edges while removing them, and use post-order traversal to reconstruct the path. Time complexity: O(E log E) where E is the number of tickets.

Common Approaches

Approach	Time	Space	Notes
✓ DFS with Backtracking (Optimal)	O(E log E)	O(E)	Use Hierholzer's algorithm with DFS to find Eulerian path efficiently
Brute Force (Try All Permutations)	O(n!)	O(n)	Generate all possible ticket arrangements and find the valid one with smallest lexicographical order

DFS with Backtracking (Optimal) — Algorithm Steps

Build adjacency list from tickets, sorting destinations for each airport
Start DFS from JFK, following the lexicographically smallest path
Use all edges exactly once (remove used tickets)
When stuck, backtrack and add current airport to result
Reverse the final path to get correct order

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Graph

Create adjacency list with sorted destinations

DFS Traversal

Follow edges, removing them as we go

Backtrack & Record

When stuck, backtrack and record the path

Reverse Result

Reverse the recorded path to get correct order

Code -

solution.c — C

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

#define MAX_AIRPORTS 1000
#define MAX_TICKETS 1000

typedef struct {
    char airports[MAX_TICKETS][4];
    int count;
} AirportList;

typedef struct {
    char airport[4];
    AirportList destinations;
} GraphNode;

GraphNode graph[MAX_AIRPORTS];
int graphSize = 0;
char result[MAX_TICKETS + 1][4];
int resultSize = 0;

int findAirportIndex(char* airport) {
    for (int i = 0; i < graphSize; i++) {
        if (strcmp(graph[i].airport, airport) == 0) {
            return i;
        }
    }
    strcpy(graph[graphSize].airport, airport);
    graph[graphSize].destinations.count = 0;
    return graphSize++;
}

int compare(const void* a, const void* b) {
    return strcmp((char*)a, (char*)b);
}

void dfs(char* airport) {
    int idx = findAirportIndex(airport);
    while (graph[idx].destinations.count > 0) {
        char next[4];
        strcpy(next, graph[idx].destinations.airports[0]);
        
        // Remove used destination
        for (int i = 0; i < graph[idx].destinations.count - 1; i++) {
            strcpy(graph[idx].destinations.airports[i], 
                   graph[idx].destinations.airports[i + 1]);
        }
        graph[idx].destinations.count--;
        
        dfs(next);
    }
    strcpy(result[resultSize++], airport);
}

char** findItinerary(char*** tickets, int ticketsSize, int* returnSize) {
    graphSize = 0;
    resultSize = 0;
    
    // Build graph
    for (int i = 0; i < ticketsSize; i++) {
        int srcIdx = findAirportIndex(tickets[i][0]);
        strcpy(graph[srcIdx].destinations.airports[graph[srcIdx].destinations.count++], 
               tickets[i][1]);
    }
    
    // Sort destinations
    for (int i = 0; i < graphSize; i++) {
        qsort(graph[i].destinations.airports, graph[i].destinations.count, 
              sizeof(char[4]), compare);
    }
    
    dfs("JFK");
    
    // Reverse result
    *returnSize = resultSize;
    char** finalResult = (char**)malloc(resultSize * sizeof(char*));
    for (int i = 0; i < resultSize; i++) {
        finalResult[i] = (char*)malloc(4 * sizeof(char));
        strcpy(finalResult[i], result[resultSize - 1 - i]);
    }
    
    return finalResult;
}

int main() {
    // Input parsing and solution call
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(E log E)

E is number of tickets. Sorting destinations takes O(E log E), DFS visits each edge once

⚡ Linearithmic

Space Complexity

O(E)

Space for adjacency list, recursion stack, and result array

✓ Linear Space

89.4K Views

Medium-High Frequency

~25 min Avg. Time

2.8K 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

Constraints

Visualization

Related Problems

Common Approaches

DFS with Backtracking (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler