Destination City - Practice Coding Problems

Destination City - Problem

Imagine you're planning a one-way road trip where each city connects to exactly one other city, forming a single chain of destinations. You're given an array of travel paths where each path paths[i] = [cityA_i, cityB_i] represents a direct route from cityA_i to cityB_i.

Your task is to find the destination city - the final stop where your journey ends. This is the city that has no outgoing paths to any other city.

Key Points:

The paths form a linear chain without any loops
There's exactly one starting city (no incoming paths) and one destination city (no outgoing paths)
Every other city has exactly one incoming and one outgoing path

Goal: Return the name of the destination city as a string.

Input & Output

example_1.py — Basic Linear Chain

$ Input: [["London","New York"],["New York","Lima"],["Lima","Sao Paulo"]]

› Output: "Sao Paulo"

💡 Note: Starting from London, we can travel to New York, then to Lima, and finally to Sao Paulo. Since there's no path leaving Sao Paulo, it's the destination city.

example_2.py — Simple Two-City Chain

$ Input: [["B","C"],["D","B"],["C","A"]]

› Output: "A"

💡 Note: The path is D → B → C → A. City A has no outgoing paths, making it the final destination.

example_3.py — Single Path Edge Case

$ Input: [["A","Z"]]

› Output: "Z"

💡 Note: With only one path from A to Z, Z is clearly the destination since it has no outgoing connections.

Constraints

1 ≤ paths.length ≤ 100
paths[i].length == 2
1 ≤ cityA_i, cityB_i ≤ 10
cityA_i != cityB_i
All city names consist of lowercase and uppercase English letters and the space character
The graph of paths forms a line without any loops

Visualization

Tap to expand

Understanding the Visualization

Map the Routes

Each path shows a one-way connection between cities

Find the Pattern

Most cities appear both as sources and destinations

Identify the End

The destination city only appears as a target, never as a source

Key Takeaway

🎯 Key Insight: The destination city is the only city that appears as a path target but never as a path source. Using a hash set to track sources allows us to find this city efficiently in O(n) time.

Asked in

a Amazon 15 G Google 8 ⊞ Microsoft 5 Apple 3

The optimal solution uses a hash set to track source cities, then finds the destination city that appears as a target but never as a source. The two-pass approach first builds the source set, then searches for the missing destination, achieving O(n) time and O(n) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	For each destination city, check if it appears as a source in any path
Two-Pass Hash Set	O(n)	O(n)	First pass: collect all source cities in a set, Second pass: find destination not in set
One-Pass Hash Set (Optimal)	O(n)	O(n)	Track sources and destinations simultaneously, return destination not in sources

Brute Force (Nested Loops) — Algorithm Steps

Iterate through each path and consider the destination city
For each destination city, search through all paths to see if it appears as a source
If a destination city never appears as a source, return it

Visualization

Tap to expand

Step-by-Step Walkthrough

Check First Destination

Look at 'New York' and search if it appears as a source

Found as Source

'New York' appears as source in another path, so it's not the destination

Check Next Destination

Look at 'Lima' and search through all paths

Check Final Destination

'Sao Paulo' doesn't appear as source anywhere - it's our answer!

Code -

solution.c — C

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

char* destCity(char*** paths, int pathsSize) {
    for (int i = 0; i < pathsSize; i++) {
        char* destination = paths[i][1];
        int isDestination = 1;
        
        // Check if this city appears as source anywhere
        for (int j = 0; j < pathsSize; j++) {
            if (strcmp(paths[j][0], destination) == 0) {
                isDestination = 0;
                break;
            }
        }
        
        if (isDestination) {
            char* result = malloc(strlen(destination) + 1);
            strcpy(result, destination);
            return result;
        }
    }
    
    return NULL; // Should never reach here
}

int main() {
    // Example usage
    char* path1[] = {"London", "New York"};
    char* path2[] = {"New York", "Lima"};
    char* path3[] = {"Lima", "Sao Paulo"};
    char** paths[] = {path1, path2, path3};
    
    char* result = destCity(paths, 3);
    printf("\"%s\"\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n paths, we potentially check all n paths again to see if destination appears as source

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables, no additional data structures

✓ Linear Space

98.0K Views

Medium Frequency

~12 min Avg. Time

2.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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler