Reachable Nodes In Subdivided Graph

Reachable Nodes In Subdivided Graph - Problem

You are given an undirected graph (the "original graph") with n nodes labeled from 0 to n - 1. You decide to subdivide each edge in the graph into a chain of nodes, with the number of new nodes varying between each edge.

The graph is given as a 2D array of edges where edges[i] = [u_i, v_i, cnt_i] indicates that there is an edge between nodes u_i and v_i in the original graph, and cnt_i is the total number of new nodes that you will subdivide the edge into. Note that cnt_i == 0 means you will not subdivide the edge.

To subdivide the edge [u_i, v_i], replace it with (cnt_i + 1) new edges and cnt_i new nodes. The new nodes are x₁, x₂, ..., x_{cnt_i}, and the new edges are [u_i, x₁], [x₁, x₂], [x₂, x₃], ..., [x_{cnt_i-1}, x_{cnt_i}], [x_{cnt_i}, v_i].

In this new graph, you want to know how many nodes are reachable from the node 0, where a node is reachable if the distance is maxMoves or less.

Given the original graph and maxMoves, return the number of nodes that are reachable from node 0 in the new graph.

Input & Output

Example 1 — Basic Case

$ Input: edges = [[0,1,10],[0,2,1],[1,2,2]], maxMoves = 6, n = 3

› Output: 13

💡 Note: From node 0: can reach node 2 (distance 2), then reach some nodes on edge [0,1] and [1,2]. Total reachable includes all original nodes and several subdivided nodes.

Example 2 — Simple Path

$ Input: edges = [[0,1,4],[1,2,6]], maxMoves = 10, n = 3

› Output: 23

💡 Note: Can traverse the entire path 0→1→2 and reach most subdivided nodes along the way within 10 moves.

Example 3 — No Subdivisions

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

› Output: 1

💡 Note: Starting from node 0, cannot reach any other nodes since node 0 is isolated. Only node 0 itself is reachable.

Constraints

0 ≤ edges.length ≤ 10⁴
0 ≤ u_i, v_i < n
There are no multiple edges in the graph
0 ≤ cnt_i ≤ 10⁴
0 ≤ maxMoves ≤ 10⁹
1 ≤ n ≤ 3000

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12

The key insight is to use Dijkstra's algorithm to find shortest paths to original nodes, then calculate how many subdivided nodes can be reached on each edge. Best approach is Dijkstra with Smart Edge Traversal. Time: O((V + E) log V), Space: O(V + E)

Common Approaches

✓ Brute Force BFS

⏱️ Time: O(E × M + V + E × M) Space: O(E × M)

Create all subdivided nodes explicitly, then use BFS from node 0 to find all nodes within maxMoves distance. This approach constructs the complete graph with all intermediate nodes.

Dijkstra with Smart Edge Traversal

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

Apply Dijkstra's algorithm on the original graph to find shortest distances to all reachable nodes. For each edge, calculate how many subdivided nodes can be reached from both endpoints within the remaining moves.

Brute Force BFS — Algorithm Steps

Build complete subdivided graph with all intermediate nodes
Run BFS from node 0 with distance tracking
Count all nodes reachable within maxMoves

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Graph

Create all intermediate nodes explicitly

BFS Traversal

Visit nodes level by level from source

Count Reachable

Count all nodes within maxMoves distance

Code -

solution.c — C

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

#define MAX_NODES 50000
#define MAX_NEIGHBORS 100

typedef struct {
    int* items;
    int front, rear, size;
} Queue;

typedef struct {
    int** neighbors;
    int* neighborCount;
    int* capacity;
} Graph;

Queue* createQueue() {
    Queue* q = malloc(sizeof(Queue));
    q->items = malloc(MAX_NODES * 2 * sizeof(int));
    q->front = q->rear = q->size = 0;
    return q;
}

void enqueue(Queue* q, int node, int dist) {
    q->items[q->rear * 2] = node;
    q->items[q->rear * 2 + 1] = dist;
    q->rear++;
    q->size++;
}

void dequeue(Queue* q, int* node, int* dist) {
    *node = q->items[q->front * 2];
    *dist = q->items[q->front * 2 + 1];
    q->front++;
    q->size--;
}

Graph* createGraph() {
    Graph* g = malloc(sizeof(Graph));
    g->neighbors = malloc(MAX_NODES * sizeof(int*));
    g->neighborCount = calloc(MAX_NODES, sizeof(int));
    g->capacity = malloc(MAX_NODES * sizeof(int));
    
    for (int i = 0; i < MAX_NODES; i++) {
        g->neighbors[i] = malloc(MAX_NEIGHBORS * sizeof(int));
        g->capacity[i] = MAX_NEIGHBORS;
    }
    return g;
}

void addEdge(Graph* g, int u, int v) {
    if (g->neighborCount[u] >= g->capacity[u]) {
        g->capacity[u] *= 2;
        g->neighbors[u] = realloc(g->neighbors[u], g->capacity[u] * sizeof(int));
    }
    g->neighbors[u][g->neighborCount[u]++] = v;
}

void freeGraph(Graph* g) {
    for (int i = 0; i < MAX_NODES; i++) {
        free(g->neighbors[i]);
    }
    free(g->neighbors);
    free(g->neighborCount);
    free(g->capacity);
    free(g);
}

int solution(int edges[][3], int edgeCount, int maxMoves, int n) {
    Graph* graph = createGraph();
    int* visited = calloc(MAX_NODES, sizeof(int));
    int nodeId = n;
    
    // Build subdivided graph
    for (int i = 0; i < edgeCount; i++) {
        int u = edges[i][0], v = edges[i][1], cnt = edges[i][2];
        if (cnt == 0) {
            addEdge(graph, u, v);
            addEdge(graph, v, u);
        } else {
            // Create intermediate nodes
            int prev = u;
            for (int j = 0; j < cnt; j++) {
                addEdge(graph, prev, nodeId);
                addEdge(graph, nodeId, prev);
                prev = nodeId;
                nodeId++;
            }
            addEdge(graph, prev, v);
            addEdge(graph, v, prev);
        }
    }
    
    // BFS from node 0
    Queue* queue = createQueue();
    enqueue(queue, 0, 0);
    visited[0] = 1;
    int reachable = 1;
    
    while (queue->size > 0) {
        int node, dist;
        dequeue(queue, &node, &dist);
        
        for (int i = 0; i < graph->neighborCount[node]; i++) {
            int neighbor = graph->neighbors[node][i];
            if (!visited[neighbor] && dist + 1 <= maxMoves) {
                visited[neighbor] = 1;
                reachable++;
                enqueue(queue, neighbor, dist + 1);
            }
        }
    }
    
    free(queue->items);
    free(queue);
    free(visited);
    freeGraph(graph);
    return reachable;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing for [[a,b,c],[d,e,f]] format
    int edges[1000][3];
    int edgeCount = 0;
    
    char* ptr = strchr(line, '[');
    ptr++; // Skip first [
    
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            edges[edgeCount][0] = strtol(ptr, &ptr, 10);
            ptr++; // Skip comma
            edges[edgeCount][1] = strtol(ptr, &ptr, 10);
            ptr++; // Skip comma
            edges[edgeCount][2] = strtol(ptr, &ptr, 10);
            edgeCount++;
        }
        ptr++;
    }
    
    int maxMoves, n;
    scanf("%d", &maxMoves);
    scanf("%d", &n);
    
    printf("%d\n", solution(edges, edgeCount, maxMoves, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(E × M + V + E × M)

Building subdivided graph takes O(E × M) where E is edges and M is average subdivision count, BFS takes O(V + E × M)

✓ Linear Growth

Space Complexity

O(E × M)

Storing all subdivided nodes and edges requires O(E × M) space

✓ Linear Space

28.5K Views

Medium Frequency

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

Brute Force BFS — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler