Destination City

Destination City - Problem

You are given an array paths, where paths[i] = [cityAi, cityBi] means there exists a direct path going from cityAi to cityBi.

Return the destination city, that is, the city without any path outgoing to another city.

It is guaranteed that the graph of paths forms a line without any loop, therefore, there will be exactly one destination city.

Input & Output

Example 1 — Basic Chain

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

› Output: "Sao Paulo"

💡 Note: Following the path: London → New York → Lima → Sao Paulo. Sao Paulo has no outgoing path, so it's the destination.

Example 2 — Simple Path

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

› Output: "A"

💡 Note: The path is D → B → C → A. City A appears as a destination but never as a source.

Example 3 — Single Path

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

› Output: "Z"

💡 Note: Only one path A → Z, so Z is the destination city with no outgoing paths.

Constraints

1 ≤ paths.length ≤ 100
paths[i].length == 2
1 ≤ cityAi.length, cityBi.length ≤ 10
cityAi ≠ cityBi
All strings consist of lowercase and uppercase English letters and the space character.

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 Apple 8 f Facebook 6

The key insight is that the destination city appears as an arrival but never as a departure. Best approach uses a hash set to store all source cities, then finds the destination not in the set. Time: O(n), Space: O(n)

Common Approaches

✓ Optimized

⏱️ Time: N/A Space: N/A

Brute Force

⏱️ Time: O(n²) Space: O(1)

Iterate through all cities that appear as destinations, and for each one, check if it appears as a source in any path. The city that doesn't appear as a source is our answer.

Hash Set Optimization

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

First pass: collect all source cities in a hash set. Second pass: find the destination city that doesn't exist in the source set. This eliminates the nested loop.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_CITIES 200
#define MAX_CITY_LEN 50

char cities[MAX_CITIES][MAX_CITY_LEN];
int cityCount = 0;
char sourceCities[MAX_CITIES][MAX_CITY_LEN];
int sourceCount = 0;

int findCity(const char* city) {
    for (int i = 0; i < cityCount; i++) {
        if (strcmp(cities[i], city) == 0) {
            return i;
        }
    }
    return -1;
}

void addCity(const char* city) {
    if (findCity(city) == -1) {
        strcpy(cities[cityCount], city);
        cityCount++;
    }
}

int isSourceCity(const char* city) {
    for (int i = 0; i < sourceCount; i++) {
        if (strcmp(sourceCities[i], city) == 0) {
            return 1;
        }
    }
    return 0;
}

void addSourceCity(const char* city) {
    if (!isSourceCity(city)) {
        strcpy(sourceCities[sourceCount], city);
        sourceCount++;
    }
}

char* solution(char paths[][2][MAX_CITY_LEN], int pathCount) {
    // Reset counters
    cityCount = 0;
    sourceCount = 0;
    
    // Add all source cities
    for (int i = 0; i < pathCount; i++) {
        addSourceCity(paths[i][0]);
        addCity(paths[i][0]);
        addCity(paths[i][1]);
    }
    
    // Find destination city
    for (int i = 0; i < pathCount; i++) {
        if (!isSourceCity(paths[i][1])) {
            static char result[MAX_CITY_LEN];
            strcpy(result, paths[i][1]);
            return result;
        }
    }
    
    return "";
}

int parsePaths(const char* str, char paths[][2][MAX_CITY_LEN]) {
    if (strcmp(str, "[]") == 0) return 0;
    
    int count = 0;
    const char* ptr = str + 1;  // Skip opening bracket
    
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;  // Skip [
            
            // Parse first city
            if (*ptr == '"') ptr++;  // Skip opening quote
            int i = 0;
            while (*ptr && *ptr != '"') {
                paths[count][0][i++] = *ptr++;
            }
            paths[count][0][i] = '\0';
            if (*ptr == '"') ptr++;  // Skip closing quote
            if (*ptr == ',') ptr++;  // Skip comma
            
            // Parse second city
            if (*ptr == '"') ptr++;  // Skip opening quote
            i = 0;
            while (*ptr && *ptr != '"') {
                paths[count][1][i++] = *ptr++;
            }
            paths[count][1][i] = '\0';
            if (*ptr == '"') ptr++;  // Skip closing quote
            if (*ptr == ']') ptr++;  // Skip closing bracket
            
            count++;
        } else {
            ptr++;
        }
    }
    
    return count;
}

int main() {
    static char pathsStr[10000];
    static char paths[MAX_CITIES][2][MAX_CITY_LEN];
    
    fgets(pathsStr, sizeof(pathsStr), stdin);
    pathsStr[strcspn(pathsStr, "\n")] = 0;  // Remove trailing newline
    
    int pathCount = parsePaths(pathsStr, paths);
    char* result = solution(paths, pathCount);
    
    printf("%s\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

✓ Linear Space

31.5K Views

Medium Frequency

~10 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