Find the Last Marked Nodes in Tree

Find the Last Marked Nodes in Tree - Problem

Imagine a viral spread simulation on a tree network! You have an undirected tree with n nodes numbered from 0 to n-1, connected by n-1 edges.

Here's how the simulation works:

At time t = 0, you mark exactly one node as the initial infection source
Every second after that, the infection spreads to all unmarked nodes that are adjacent to any already marked node
This continues until every node in the tree is marked

Your task: For each possible starting node i, determine which node will be the very last to get marked. Return an array where result[i] is the last node to be marked when starting from node i.

Note: If there are multiple nodes that could be last (tied for the same time), you can return any of them.

Input & Output

example_1.py — Basic Tree

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

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

💡 Note: Tree: 2-0-1-3. Starting from 0: node 3 is farthest. Starting from 1: node 2 is farthest (distance 3). Starting from 2: node 3 is farthest (distance 3). Starting from 3: node 2 is farthest (distance 3).

example_2.py — Linear Tree

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

› Output: [4, 4, 4, 0, 0]

💡 Note: Linear tree: 0-1-2-3-4. When starting from nodes 0,1,2, node 4 is farthest. When starting from nodes 3,4, node 0 is farthest.

example_3.py — Single Node

$ Input: edges = []

› Output: [0]

💡 Note: Only one node exists (node 0), so when starting from node 0, node 0 itself is the last (and only) node to be marked.

Constraints

1 ≤ n ≤ 10⁵
edges.length == n - 1
0 ≤ u_i, v_i < n
The input represents a valid tree (connected and acyclic)

Visualization

Tap to expand

Asked in

G Google 28 a Amazon 22 f Meta 15 ⊞ Microsoft 12

The key insight is that the last marked node is always at maximum distance from the starting node. In trees, nodes at maximum distance are always diameter endpoints. The optimal approach finds the tree's diameter using two BFS passes, then for each starting node, determines which diameter endpoint is farther away.

Common Approaches

✓ Sort First

⏱️ Time: N/A Space: N/A

Brute Force (BFS Simulation)

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

For each possible starting node, run a complete BFS simulation to find which node gets marked last. This involves doing a level-by-level traversal and tracking the order of marking.

Two-Pass Tree Diameter

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

The key insight is that the last marked node is always at maximum distance from the starting node. In a tree, nodes at maximum distance from any node are always one of the diameter endpoints. We can find the diameter efficiently and then determine which endpoint is farther for each starting node.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    int *pointA = (int *)a;
    int *pointB = (int *)b;
    if (pointA[0] == pointB[0]) {
        return pointB[1] - pointA[1]; // y descending
    }
    return pointA[0] - pointB[0]; // x ascending
}

int solution(int points[][2], int n) {
    int count = 0;
    
    // Sort points by x-coordinate, then by y-coordinate descending
    qsort(points, n, sizeof(int[2]), compare);
    
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            int x1 = points[i][0], y1 = points[i][1];
            int x2 = points[j][0], y2 = points[j][1];
            
            // Check if point i is upper-left of point j and forms a proper rectangle
            if (x1 < x2 && y1 > y2) {
                // Check if any other point lies in the rectangle
                int valid = 1;
                for (int k = 0; k < n; k++) {
                    if (k == i || k == j) continue;
                    
                    int x3 = points[k][0], y3 = points[k][1];
                    // Point k is in rectangle if x1 <= x3 <= x2 and y2 <= y3 <= y1
                    if (x1 <= x3 && x3 <= x2 && y2 <= y3 && y3 <= y1) {
                        valid = 0;
                        break;
                    }
                }
                
                if (valid) {
                    count++;
                }
            }
        }
    }
    
    return count;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing for [[x1,y1],[x2,y2],...]
    int points[1000][2];
    int n = 0;
    char *ptr = line + 1; // Skip first '['
    
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            points[n][0] = strtol(ptr, &ptr, 10);
            ptr++; // Skip comma
            points[n][1] = strtol(ptr, &ptr, 10);
            n++;
            ptr++; // Skip ']'
        }
        ptr++;
    }
    
    int result = solution(points, n);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~25 min Avg. Time

890 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