Codestin Search App

Find the Closest Marked Node - Problem

Imagine you're a delivery driver navigating a city with one-way streets, and you need to find the shortest route to any of your delivery destinations from your current location.

You're given a directed weighted graph representing a city where:

There are n intersections (nodes) numbered from 0 to n-1
Each edge [u, v, w] represents a one-way street from intersection u to intersection v with travel time w
You start at intersection s
You have multiple possible destinations stored in the marked array

Your goal: Find the minimum travel time from your starting point s to reach any of the marked destinations. If no destinations are reachable, return -1.

Example: If you're at intersection 0 and need to deliver to intersections [2, 3], find the shortest path to whichever destination is closest.

Input & Output

example_1.py — Basic Graph

$ Input: n = 4, edges = [[0,1,1],[1,2,2],[0,3,4]], s = 0, marked = [2,3]

› Output: 3

💡 Note: From node 0, we can reach node 2 with distance 1+2=3 (path: 0→1→2) and node 3 with distance 4 (path: 0→3). The minimum distance to any marked node is 3.

example_2.py — No Path Exists

$ Input: n = 3, edges = [[0,1,2]], s = 0, marked = [2]

› Output: -1

💡 Note: There is no path from node 0 to node 2, so we return -1.

example_3.py — Source is Marked

$ Input: n = 4, edges = [[0,1,5],[1,2,3]], s = 0, marked = [0,2]

› Output: 0

💡 Note: The source node 0 is itself marked, so the minimum distance is 0.

Constraints

2 ≤ n ≤ 500
1 ≤ edges.length ≤ 10⁴
edges[i].length == 3
0 ≤ ui, vi ≤ n-1
1 ≤ wi ≤ 100
1 ≤ marked.length ≤ n
All marked nodes are distinct
0 ≤ s ≤ n-1

Visualization

Tap to expand

Understanding the Visualization

Mark Destinations

Identify all possible destinations (marked nodes) in a set for quick lookup

Start Exploration

Begin Dijkstra's algorithm from source, exploring closest nodes first

Early Termination

Stop immediately when any marked destination is reached - it's guaranteed to be the closest

Key Takeaway

🎯 Key Insight: Dijkstra's algorithm explores nodes in order of increasing distance from the source, so the first marked destination encountered is guaranteed to be the globally closest one!

Asked in

G Google 42 a Amazon 38 f Meta 29 ⊞ Microsoft 24 Apple 18

The optimal approach uses single Dijkstra's algorithm with early termination. Instead of running separate shortest path algorithms for each marked destination, we run Dijkstra once from the source and stop as soon as we encounter any marked node. This works because Dijkstra processes nodes in order of increasing distance, so the first marked node we reach is guaranteed to be the closest one. Time complexity: O((E + V) log V), which is optimal for this problem.

Common Approaches

Approach	Time	Space	Notes
✓ Multiple Dijkstra's Algorithm	O(k * (E + V) log V)	O(V)	Run Dijkstra's algorithm separately for each marked destination
Single Dijkstra with Early Termination (Optimal)	O((E + V) log V)	O(V + E)	Run Dijkstra once, stopping at the first marked destination encountered

Multiple Dijkstra's Algorithm — Algorithm Steps

Initialize minimum distance as infinity
For each marked destination node:
Run Dijkstra's algorithm from source s to this destination
Update minimum distance if a shorter path is found
Return minimum distance, or -1 if no paths exist

Visualization

Tap to expand

Step-by-Step Walkthrough

First Destination

Run Dijkstra from source to first marked node

Second Destination

Run Dijkstra from source to second marked node

Compare Results

Keep track of minimum distance found

Code -

solution.c — C

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

#define MAX_NODES 1000

typedef struct {
    int to, weight;
} Edge;

typedef struct {
    int node, dist;
} PQItem;

int minimumDistance(int n, int** edges, int edgesSize, int* edgesColSize, int s, int* marked, int markedSize) {
    // Build adjacency list (simplified)
    Edge graph[MAX_NODES][MAX_NODES];
    int graphSize[MAX_NODES] = {0};
    
    for (int i = 0; i < edgesSize; i++) {
        int u = edges[i][0];
        graph[u][graphSize[u]++] = (Edge){edges[i][1], edges[i][2]};
    }
    
    int minDist = INT_MAX;
    
    for (int t = 0; t < markedSize; t++) {
        int target = marked[t];
        int dist[MAX_NODES];
        for (int i = 0; i < n; i++) dist[i] = INT_MAX;
        dist[s] = 0;
        
        // Simple priority queue simulation
        int visited[MAX_NODES] = {0};
        
        for (int i = 0; i < n; i++) {
            int u = -1;
            for (int j = 0; j < n; j++) {
                if (!visited[j] && (u == -1 || dist[j] < dist[u])) {
                    u = j;
                }
            }
            
            if (dist[u] == INT_MAX) break;
            if (u == target) {
                if (dist[u] < minDist) minDist = dist[u];
                break;
            }
            
            visited[u] = 1;
            
            for (int j = 0; j < graphSize[u]; j++) {
                int v = graph[u][j].to;
                int w = graph[u][j].weight;
                if (dist[u] + w < dist[v]) {
                    dist[v] = dist[u] + w;
                }
            }
        }
    }
    
    return minDist == INT_MAX ? -1 : minDist;
}

Time & Space Complexity

Time Complexity

⏱️

O(k * (E + V) log V)

k marked destinations × Dijkstra's complexity, where E is edges and V is vertices

⚡ Linearithmic

Space Complexity

O(V)

Space for priority queue and distance array in each Dijkstra run

✓ Linear Space

68.9K Views

High Frequency

~18 min Avg. Time

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

Multiple Dijkstra's Algorithm — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler