Reconstruct Itinerary

Reconstruct Itinerary - Problem

You are given a list of airline tickets where tickets[i] = [from_i, to_i] represent the departure and the arrival airports of one flight. Reconstruct the itinerary in order and return it.

All of the tickets belong to a man who departs from "JFK", thus, the itinerary must begin with "JFK". If there are multiple valid itineraries, you should return the itinerary that has the smallest lexical order when read as a single string.

For example, the itinerary ["JFK", "LGA"] has a smaller lexical order than ["JFK", "LGB"].

You may assume all tickets form at least one valid itinerary. You must use all the tickets once and only once.

Input & Output

Example 1 — Basic Circuit

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

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

💡 Note: Start from JFK, follow tickets: JFK → MUC → LHR → SFO → SJC. This uses all tickets exactly once.

Example 2 — 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 return the lexicographically smallest one.

Example 3 — Simple Round Trip

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

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

💡 Note: Simple round trip: JFK → KUL → JFK using both tickets.

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
from_i ≠ to_i

Visualization

Tap to expand

Asked in

G Google 42 a Amazon 35 f Facebook 28 M Microsoft 24

This is an Eulerian path problem where we need to visit every edge (ticket) exactly once. The optimal approach uses Hierholzer's algorithm with DFS and sorted adjacency lists to ensure lexical ordering. Time: O(V + E), Space: O(V + E).

Common Approaches

✓ Brute Force with Permutations

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

Try every possible permutation of tickets, check if each forms a valid path starting from JFK, and return the lexicographically smallest one.

DFS with Backtracking

⏱️ Time: O(V + E)² Space: O(V + E)

Create adjacency list from tickets, sort destinations for lexical order, then use DFS with backtracking to find valid path using all tickets.

Hierholzer's Algorithm (Eulerian Path)

⏱️ Time: O(V + E) Space: O(V + E)

This is an Eulerian path problem where we need to visit every edge (ticket) exactly once. Use Hierholzer's algorithm with sorted adjacency lists to ensure lexical ordering.

Brute Force with Permutations — Algorithm Steps

Generate all permutations of tickets
For each permutation, check if it forms a valid path
Return the lexicographically smallest valid itinerary

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutations

Create all possible arrangements of tickets

Validate Path

Check if each arrangement forms valid itinerary from JFK

Select Minimum

Choose lexicographically smallest valid itinerary

Code -

solution.c — C

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

#define MAX_TICKETS 300
#define MAX_LEN 10

static char tickets[MAX_TICKETS][2][MAX_LEN];
static char allPerms[40320][MAX_TICKETS][2][MAX_LEN];
static int permCount = 0;
static char validItineraries[40320][MAX_TICKETS + 1][MAX_LEN];
static int validCount = 0;
static int itinerarySizes[40320];

void generatePermutations(int ticketsSize, char current[][2][MAX_LEN], int currentSize, int used[]) {
    if (currentSize == ticketsSize) {
        for (int i = 0; i < ticketsSize; i++) {
            strcpy(allPerms[permCount][i][0], current[i][0]);
            strcpy(allPerms[permCount][i][1], current[i][1]);
        }
        permCount++;
        return;
    }
    
    for (int i = 0; i < ticketsSize; i++) {
        if (!used[i]) {
            used[i] = 1;
            strcpy(current[currentSize][0], tickets[i][0]);
            strcpy(current[currentSize][1], tickets[i][1]);
            generatePermutations(ticketsSize, current, currentSize + 1, used);
            used[i] = 0;
        }
    }
}

int isValidPath(int permIdx, int ticketsSize) {
    if (ticketsSize == 0 || strcmp(allPerms[permIdx][0][0], "JFK") != 0) {
        return 0;
    }
    for (int i = 0; i < ticketsSize - 1; i++) {
        if (strcmp(allPerms[permIdx][i][1], allPerms[permIdx][i + 1][0]) != 0) {
            return 0;
        }
    }
    return 1;
}

void getItinerary(int permIdx, int ticketsSize, int validIdx) {
    if (ticketsSize == 0) {
        itinerarySizes[validIdx] = 0;
        return;
    }
    strcpy(validItineraries[validIdx][0], allPerms[permIdx][0][0]);
    for (int i = 0; i < ticketsSize; i++) {
        strcpy(validItineraries[validIdx][i + 1], allPerms[permIdx][i][1]);
    }
    itinerarySizes[validIdx] = ticketsSize + 1;
}

int compareItineraries(const void* a, const void* b) {
    int idxA = *(int*)a;
    int idxB = *(int*)b;
    int minSize = itinerarySizes[idxA] < itinerarySizes[idxB] ? itinerarySizes[idxA] : itinerarySizes[idxB];
    
    for (int i = 0; i < minSize; i++) {
        int cmp = strcmp(validItineraries[idxA][i], validItineraries[idxB][i]);
        if (cmp != 0) return cmp;
    }
    return itinerarySizes[idxA] - itinerarySizes[idxB];
}

void solution(int ticketsSize, char result[][MAX_LEN], int* resultSize) {
    permCount = 0;
    validCount = 0;
    
    static char current[MAX_TICKETS][2][MAX_LEN];
    int used[MAX_TICKETS] = {0};
    
    generatePermutations(ticketsSize, current, 0, used);
    
    for (int i = 0; i < permCount; i++) {
        if (isValidPath(i, ticketsSize)) {
            getItinerary(i, ticketsSize, validCount);
            validCount++;
        }
    }
    
    if (validCount == 0) {
        *resultSize = 0;
        return;
    }
    
    int indices[40320];
    for (int i = 0; i < validCount; i++) {
        indices[i] = i;
    }
    
    qsort(indices, validCount, sizeof(int), compareItineraries);
    
    int bestIdx = indices[0];
    *resultSize = itinerarySizes[bestIdx];
    for (int i = 0; i < *resultSize; i++) {
        strcpy(result[i], validItineraries[bestIdx][i]);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int ticketsSize = 0;
    
    if (strcmp(line, "[]\n") == 0) {
        printf("[]\n");
        return 0;
    }
    
    char* ptr = line + 1;
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            char* start = ptr;
            while (*ptr && *ptr != '"') ptr++;
            if (*ptr == '"') {
                ptr++;
                char* from_start = ptr;
                while (*ptr && *ptr != '"') ptr++;
                *ptr = '\0';
                strcpy(tickets[ticketsSize][0], from_start);
                ptr++;
                
                while (*ptr && *ptr != '"') ptr++;
                if (*ptr == '"') {
                    ptr++;
                    char* to_start = ptr;
                    while (*ptr && *ptr != '"') ptr++;
                    *ptr = '\0';
                    strcpy(tickets[ticketsSize][1], to_start);
                    ticketsSize++;
                    ptr++;
                }
            }
        }
        if (*ptr) ptr++;
    }
    
    char result[MAX_TICKETS + 1][MAX_LEN];
    int resultSize;
    solution(ticketsSize, result, &resultSize);
    
    printf("[");
    for (int i = 0; i < resultSize; i++) {
        printf("\"%s\"", result[i]);
        if (i < resultSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n!)

Generating all n! permutations of tickets

✓ Linear Growth

Space Complexity

O(n)

Space for storing current permutation and result

✓ Linear Space

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

Brute Force with Permutations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler