The Most Similar Path in a Graph - Practice Coding Problems

The Most Similar Path in a Graph - Problem

You're given an undirected connected graph with n cities and m bi-directional roads. Each city has a unique three-letter name (like "NYC", "LAX", "SFO"), and you can travel between any two cities following the road connections.

Your task is to find a path of specific length that has the minimum edit distance to a given target path. The edit distance counts how many positions differ between your path and the target path.

Goal: Find any valid path with the same length as targetPath that minimizes the number of different city names at corresponding positions.

Input:

n cities with names[i] containing exactly 3 uppercase letters
roads[i] = [a, b] representing bi-directional connections
targetPath - the desired sequence of city names to match

Output: Return the indices of cities forming the optimal path

Input & Output

example_1.py — Basic Path Matching

$ Input: n = 5, roads = [[0,2],[0,3],[1,2],[1,3],[1,4],[2,4]], names = ["NYC","LAX","SFO","CHI","PHX"], targetPath = ["NYC","LAX","SFO"]

› Output: [0,2,4] or [0,3,4]

💡 Note: The target path wants NYC→LAX→SFO, but LAX (city 1) is not directly connected to SFO (city 4). We can use NYC→SFO→PHX which has edit distance of 2 (mismatches at positions 1 and 2), or find a better path if available.

example_2.py — Perfect Match Available

$ Input: n = 4, roads = [[0,1],[1,2],[2,3],[0,3]], names = ["NYC","LAX","SFO","CHI"], targetPath = ["NYC","LAX","SFO"]

› Output: [0,1,2]

💡 Note: Perfect match exists! NYC (0) → LAX (1) → SFO (2) matches the target path exactly with edit distance 0.

example_3.py — No Direct Path

$ Input: n = 3, roads = [[0,1],[1,2]], names = ["ABC","DEF","GHI"], targetPath = ["GHI","DEF","ABC"]

› Output: [2,1,0]

💡 Note: Target wants GHI→DEF→ABC. The only path of length 3 is either 2→1→0 (perfect match) or 0→1→2 (all mismatches). The optimal path [2,1,0] has edit distance 0.

Constraints

2 ≤ n ≤ 100
n-1 ≤ roads.length ≤ n*(n-1)/2
roads[i].length == 2
0 ≤ a_i, b_i ≤ n-1
a_i != b_i
roads represents a connected undirected graph
names.length == n
names[i].length == 3
names[i] consists of uppercase English letters
1 ≤ targetPath.length ≤ 100
targetPath[i].length == 3

Visualization

Tap to expand

Understanding the Visualization

Map the Cities

Build a graph representing all city connections

Compare Preferences

At each step, check if current city matches target preference

Build Optimal Routes

Use DP to find minimum mismatches for each position and city

Choose Best Path

Select the complete route with minimum total mismatches

Key Takeaway

🎯 Key Insight: Dynamic Programming allows us to build optimal paths incrementally, avoiding exponential brute force while guaranteeing the minimum edit distance solution.

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal solution uses Dynamic Programming with time complexity O(L × n × d). Define dp[pos][city] as the minimum edit distance for paths of length pos+1 ending at city. Build the DP table bottom-up and backtrack to reconstruct the optimal path.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(L * n * d)	O(L * n)	Use DP to build optimal path considering current city and position

Dynamic Programming (Optimal) — Algorithm Steps

Initialize DP table: dp[pos][city] = min edit distance
Base case: dp[0][city] = 0 if names[city] == targetPath[0], else 1
Fill DP table: for each position, try all cities reachable from previous cities
Backtrack from minimum final state to reconstruct optimal path

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Base Case

Set costs for first position based on name matching

Fill DP Table

For each position, find minimum cost to reach each city

Find Optimal End

Choose ending city with minimum total edit distance

Backtrack Path

Reconstruct optimal path using parent pointers

Code -

solution.c — C

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

#define MAX_CITIES 100

int graph[MAX_CITIES][MAX_CITIES];
int graphSize[MAX_CITIES];

int* mostSimilar(int n, int** roads, int roadsSize, int* roadsColSize, 
                char** names, int namesSize, char** targetPath, 
                int targetPathSize, int* returnSize) {
    
    // Build adjacency list
    memset(graphSize, 0, sizeof(graphSize));
    for (int i = 0; i < roadsSize; i++) {
        int a = roads[i][0], b = roads[i][1];
        graph[a][graphSize[a]++] = b;
        graph[b][graphSize[b]++] = a;
    }
    
    // DP table and parent tracking
    static int dp[MAX_CITIES][MAX_CITIES];
    static int parent[MAX_CITIES][MAX_CITIES];
    
    // Initialize
    for (int i = 0; i < targetPathSize; i++) {
        for (int j = 0; j < n; j++) {
            dp[i][j] = INT_MAX;
            parent[i][j] = -1;
        }
    }
    
    // Base case
    for (int city = 0; city < n; city++) {
        dp[0][city] = (strcmp(names[city], targetPath[0]) == 0) ? 0 : 1;
    }
    
    // Fill DP table
    for (int pos = 1; pos < targetPathSize; pos++) {
        for (int city = 0; city < n; city++) {
            int currCost = (strcmp(names[city], targetPath[pos]) == 0) ? 0 : 1;
            
            for (int i = 0; i < graphSize[city]; i++) {
                int prevCity = graph[city][i];
                if (dp[pos-1][prevCity] != INT_MAX) {
                    int newCost = dp[pos-1][prevCity] + currCost;
                    if (newCost < dp[pos][city]) {
                        dp[pos][city] = newCost;
                        parent[pos][city] = prevCity;
                    }
                }
            }
        }
    }
    
    // Find best ending city
    int minDist = dp[targetPathSize-1][0];
    int bestEnd = 0;
    for (int city = 1; city < n; city++) {
        if (dp[targetPathSize-1][city] < minDist) {
            minDist = dp[targetPathSize-1][city];
            bestEnd = city;
        }
    }
    
    // Reconstruct path
    int* result = (int*)malloc(sizeof(int) * targetPathSize);
    int pos = targetPathSize - 1;
    int city = bestEnd;
    
    while (pos >= 0) {
        result[pos] = city;
        if (pos > 0) {
            city = parent[pos][city];
        }
        pos--;
    }
    
    *returnSize = targetPathSize;
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(L * n * d)

L path length, n cities, d average degree - polynomial time

✓ Linear Growth

Space Complexity

O(L * n)

DP table storing states for each position and city

⚡ Linearithmic Space

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler