Time Taken to Mark All Nodes

Time Taken to Mark All Nodes - Problem

There exists an undirected tree with n nodes numbered 0 to n - 1. You are given a 2D integer array edges of length n - 1, where edges[i] = [ui, vi] indicates that there is an edge between nodes ui and vi in the tree.

Initially, all nodes are unmarked. For each node i:

If i is odd, the node will get marked at time x if there is at least one node adjacent to it which was marked at time x - 1.
If i is even, the node will get marked at time x if there is at least one node adjacent to it which was marked at time x - 2.

Return an array times where times[i] is the time when all nodes get marked in the tree, if you mark node i at time t = 0.

Note that the answer for each times[i] is independent, i.e. when you mark node i all other nodes are unmarked.

Input & Output

Example 1 — Simple Chain

$ Input: edges = [[0,1],[1,2]]

› Output: [3,2,3]

💡 Note: Starting from node 0: 0→1 (t=1) then 1→2 (t=3), max=3. Starting from node 1: 1→0 (t=2) and 1→2 (t=2), max=2. Starting from node 2: 2→1 (t=1) then 1→0 (t=3), max=3.

Example 2 — Single Edge

$ Input: edges = [[0,1]]

› Output: [1,2]

💡 Note: From node 0: mark node 1 at time 1 (odd). From node 1: mark node 0 at time 2 (even).

Example 3 — Star Graph

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

› Output: [2,2,2,2]

💡 Note: Node 1 connects to all others. From any node, the maximum time depends on the parity rules and distances.

Constraints

1 ≤ n ≤ 10⁵
edges.length == n - 1
0 ≤ u_i, v_i ≤ n - 1
The given input represents a valid tree.

Visualization

Tap to expand

Asked in

M Meta 8 G Google 5

The key insight is that different node parities create asymmetric spreading patterns in the tree. The optimal approach uses tree rerooting dynamic programming to avoid redundant BFS computations. Time: O(n), Space: O(n).

Common Approaches

✓ Brute Force Simulation

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

For each starting node, run a BFS simulation where nodes get marked based on their parity rules. Track the time when all nodes become marked.

Tree Rerooting Dynamic Programming

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

First compute the answer for one root, then use tree rerooting technique to adjust answers for all other roots in a single pass, avoiding repeated BFS computations.

Brute Force Simulation — Algorithm Steps

For each node as starting point
Run BFS with timing rules
Track when all nodes are marked

Visualization

Tap to expand

Step-by-Step Walkthrough

Choose Start

Select a node as starting point (time 0)

BFS Spread

Apply timing rules: odd nodes +1, even nodes +2

Record Max

Track maximum time when all nodes are marked

Code -

solution.c — C

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

#define MAX_N 1000

static int graph[MAX_N][MAX_N];
static int graphSize[MAX_N];
static int marked_time[MAX_N];

int* solution(int** edges, int edgesSize, int* edgesColSize, int* returnSize) {
    if (edgesSize == 0) {
        *returnSize = 1;
        int* result = (int*)malloc(sizeof(int));
        result[0] = 0;
        return result;
    }
    
    int n = edgesSize + 1;
    *returnSize = n;
    int* result = (int*)malloc(n * sizeof(int));
    
    // Initialize graph
    for (int i = 0; i < n; i++) {
        graphSize[i] = 0;
    }
    
    // Build adjacency list
    for (int i = 0; i < edgesSize; i++) {
        int u = edges[i][0];
        int v = edges[i][1];
        graph[u][graphSize[u]++] = v;
        graph[v][graphSize[v]++] = u;
    }
    
    // For each starting node
    for (int start = 0; start < n; start++) {
        // Initialize marked times
        for (int i = 0; i < n; i++) {
            marked_time[i] = -1;
        }
        marked_time[start] = 0;
        int marked_count = 1;
        int time = 0;
        
        while (marked_count < n) {
            time += 1;
            int newly_marked[MAX_N];
            int newly_marked_count = 0;
            
            for (int node = 0; node < n; node++) {
                if (marked_time[node] == -1) {  // unmarked
                    int can_mark = 0;
                    
                    if (node % 2 == 1) {  // odd node
                        // Can be marked if has neighbor marked at time-1
                        for (int i = 0; i < graphSize[node]; i++) {
                            int neighbor = graph[node][i];
                            if (marked_time[neighbor] == time - 1) {
                                can_mark = 1;
                                break;
                            }
                        }
                    } else {  // even node
                        // Can be marked if time >= 2 and has neighbor marked at time-2
                        if (time >= 2) {
                            for (int i = 0; i < graphSize[node]; i++) {
                                int neighbor = graph[node][i];
                                if (marked_time[neighbor] == time - 2) {
                                    can_mark = 1;
                                    break;
                                }
                            }
                        }
                    }
                    
                    if (can_mark) {
                        newly_marked[newly_marked_count++] = node;
                    }
                }
            }
            
            for (int i = 0; i < newly_marked_count; i++) {
                int node = newly_marked[i];
                marked_time[node] = time;
                marked_count += 1;
            }
        }
        
        result[start] = time;
    }
    
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Remove newline if present
    int len = strlen(line);
    if (len > 0 && line[len-1] == '\n') {
        line[len-1] = '\0';
        len--;
    }
    
    int edges[MAX_N][2];
    int edgesSize = 0;
    
    if (strncmp(line, "[]", 2) == 0) {
        printf("[0]\n");
        return 0;
    }
    
    // Parse JSON array format: [[0,1],[1,2],...]
    int pos = 1; // Skip opening [
    while (pos < len && line[pos] != ']') {
        if (line[pos] == '[') {
            pos++; // Skip [
            int nums[2];
            int numCount = 0;
            int currentNum = 0;
            int hasNum = 0;
            
            while (pos < len && line[pos] != ']' && numCount < 2) {
                if (line[pos] >= '0' && line[pos] <= '9') {
                    currentNum = currentNum * 10 + (line[pos] - '0');
                    hasNum = 1;
                } else if (line[pos] == ',' && hasNum) {
                    nums[numCount++] = currentNum;
                    currentNum = 0;
                    hasNum = 0;
                }
                pos++;
            }
            
            if (hasNum && numCount < 2) {
                nums[numCount++] = currentNum;
            }
            
            if (numCount == 2) {
                edges[edgesSize][0] = nums[0];
                edges[edgesSize][1] = nums[1];
                edgesSize++;
            }
            
            // Skip to end of current pair
            while (pos < len && line[pos] != ']') pos++;
            if (pos < len && line[pos] == ']') pos++;
        } else {
            pos++;
        }
    }
    
    int* edgesPtrs[MAX_N];
    for (int i = 0; i < edgesSize; i++) {
        edgesPtrs[i] = edges[i];
    }
    
    int returnSize;
    int* result = solution(edgesPtrs, edgesSize, NULL, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n starting nodes, we run BFS which visits all n nodes

✓ Linear Growth

Space Complexity

O(n)

Queue for BFS and visited array for each simulation

⚡ Linearithmic Space

8.4K Views

Medium Frequency

~35 min Avg. Time

256 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 Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler