Find the Closest Marked Node

Find the Closest Marked Node - Problem

You are given a positive integer n which is the number of nodes of a 0-indexed directed weighted graph and a 0-indexed 2D array edges where edges[i] = [ui, vi, wi] indicates that there is an edge from node ui to node vi with weight wi.

You are also given a node s and a node array marked; your task is to find the minimum distance from s to any of the nodes in marked.

Return an integer denoting the minimum distance from s to any node in marked or -1 if there are no paths from s to any of the marked nodes.

Input & Output

Example 1 — Basic Case

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

› Output: 3

💡 Note: Shortest path from node 0 to any marked node: 0→2 has distance 3, 0→1→3 has distance 7, so minimum is 3

Example 2 — No Path Available

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

› Output: -1

💡 Note: No path exists from node 0 to marked node 2, so return -1

Example 3 — Source is Marked

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

› Output: 0

💡 Note: Source node 0 is itself marked, so distance is 0

Constraints

2 ≤ n ≤ 10⁵
1 ≤ edges.length ≤ 10⁵
edges[i].length == 3
0 ≤ u_i, v_i ≤ n - 1
1 ≤ w_i ≤ 10⁶
0 ≤ s ≤ n - 1
1 ≤ marked.length ≤ n

Visualization

Tap to expand

Asked in

G Google 42 a Amazon 38 M Microsoft 31 f Meta 25

The key insight is to use Dijkstra's shortest path algorithm with early termination - stop as soon as we reach any marked node rather than computing shortest paths to all nodes. Build an adjacency list from edges, then use a priority queue to explore nodes in order of shortest distance. Best approach is Dijkstra's Algorithm with Time: O(E log V), Space: O(V + E).

Common Approaches

✓ Brute Force DFS

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

Recursively explore all possible paths from the source node, keeping track of distances. For each marked node reachable, record the minimum distance found.

Dijkstra's Algorithm

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

Build adjacency list and use Dijkstra's algorithm to find shortest distances from source. Stop early when we reach any marked node.

Brute Force DFS — Algorithm Steps

Build adjacency list from edges
For each marked node, use DFS to find minimum distance
Return the smallest distance found, or -1 if none reachable

Visualization

Tap to expand

Step-by-Step Walkthrough

Start DFS

Begin at source node s

Explore Paths

Recursively visit all neighbors, tracking distances

Check Marked

When reaching marked nodes, update minimum distance

Code -

solution.c — C

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

#define MAX_NODES 100005
#define MAX_EDGES 100005

typedef struct {
    int to, weight;
} Edge;

Edge graph[MAX_NODES][1000];
int graphSize[MAX_NODES];
int markedSet[MAX_NODES];
int visited[MAX_NODES];
int minDist;

void dfs(int node, int dist) {
    if (markedSet[node]) {
        if (dist < minDist) {
            minDist = dist;
        }
        return;
    }
    
    if (visited[node]) return;
    
    visited[node] = 1;
    for (int i = 0; i < graphSize[node]; i++) {
        dfs(graph[node][i].to, dist + graph[node][i].weight);
    }
    visited[node] = 0;
}

int solution(int n, int edges[][3], int edgeCount, int s, int marked[], int markedCount) {
    memset(graphSize, 0, sizeof(graphSize));
    memset(markedSet, 0, sizeof(markedSet));
    memset(visited, 0, sizeof(visited));
    
    for (int i = 0; i < edgeCount; i++) {
        int u = edges[i][0], v = edges[i][1], w = edges[i][2];
        graph[u][graphSize[u]].to = v;
        graph[u][graphSize[u]].weight = w;
        graphSize[u]++;
    }
    
    for (int i = 0; i < markedCount; i++) {
        markedSet[marked[i]] = 1;
    }
    
    minDist = INT_MAX;
    dfs(s, 0);
    
    return minDist == INT_MAX ? -1 : minDist;
}

int main() {
    int n, s;
    scanf("%d\n", &n);
    
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse edges
    int edges[MAX_EDGES][3];
    int edgeCount = 0;
    
    if (strcmp(line, "[]\n") != 0) {
        char* ptr = line + 1; // Skip first '['
        while (*ptr && *ptr != ']') {
            if (*ptr == '[') {
                ptr++;
                edges[edgeCount][0] = strtol(ptr, &ptr, 10);
                ptr++; // Skip ','
                edges[edgeCount][1] = strtol(ptr, &ptr, 10);
                ptr++; // Skip ','
                edges[edgeCount][2] = strtol(ptr, &ptr, 10);
                edgeCount++;
                while (*ptr && *ptr != ']') ptr++;
                if (*ptr == ']') ptr++;
            } else {
                ptr++;
            }
        }
    }
    
    scanf("%d\n", &s);
    fgets(line, sizeof(line), stdin);
    
    // Parse marked
    int marked[MAX_NODES];
    int markedCount = 0;
    
    if (strcmp(line, "[]\n") != 0) {
        char* ptr = line + 1; // Skip '['
        while (*ptr && *ptr != ']') {
            marked[markedCount++] = strtol(ptr, &ptr, 10);
            if (*ptr == ',') ptr++;
        }
    }
    
    printf("%d\n", solution(n, edges, edgeCount, s, marked, markedCount));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2ⁿ)

In worst case, explores all possible paths which can be exponential

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth plus adjacency list storage

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~25 min Avg. Time

847 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 DFS — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler