Minimum Time to Collect All Apples in a Tree

Minimum Time to Collect All Apples in a Tree - Problem

Given an undirected tree consisting of n vertices numbered from 0 to n-1, which has some apples in their vertices. You spend 1 second to walk over one edge of the tree.

Return the minimum time in seconds you have to spend to collect all apples in the tree, starting at vertex 0 and coming back to this vertex.

The edges of the undirected tree are given in the array edges, where edges[i] = [ai, bi] means that exists an edge connecting the vertices ai and bi. Additionally, there is a boolean array hasApple, where hasApple[i] = true means that vertex i has an apple; otherwise, it does not have any apple.

Input & Output

Example 1 — Basic Tree

$ Input: n = 7, edges = [[0,1],[0,2],[1,4],[1,5],[2,3],[2,6]], hasApple = [false,false,true,false,true,true,false]

› Output: 8

💡 Note: Start at 0. Go to node 2 (2 seconds), collect apple at node 2, then go to node 3 (2 seconds), return to 2 (2 seconds), then return to 0 (2 seconds). Total: 8 seconds.

Example 2 — Single Apple

$ Input: n = 7, edges = [[0,1],[0,2],[1,4],[1,5],[2,3],[2,6]], hasApple = [false,false,false,false,false,false,false]

› Output: 0

💡 Note: No apples to collect, so no need to move from starting position. Total: 0 seconds.

Example 3 — All Apples

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

› Output: 6

💡 Note: Must visit all nodes: 0→1→2 (return to 1, then 0), then 0→3 (return to 0). Path: 0→1→2→1→0→3→0. Total: 6 seconds.

Constraints

1 ≤ n ≤ 10⁵
edges.length == n - 1
edges[i].length == 2
0 ≤ ai, bi ≤ n - 1
ai ≠ bi
hasApple.length == n

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15 🍎 Apple 12

The key insight is to use DFS to only traverse subtrees that contain at least one apple, avoiding unnecessary branches. The optimal approach uses recursive DFS to check if a subtree has apples before visiting it. Time: O(n), Space: O(n)

Common Approaches

✓ Brute Force - Visit All Paths

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

Build the entire tree structure and traverse every edge multiple times. This approach doesn't optimize for apple locations and visits unnecessary branches.

DFS with Apple-aware Pruning

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

Perform depth-first search but only traverse edges that lead to subtrees containing at least one apple. This avoids unnecessary visits to apple-free branches.

Brute Force - Visit All Paths — Algorithm Steps

Build adjacency list for the tree
Perform DFS from node 0
Visit all neighbors recursively
Count total edges traversed

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Graph

Create adjacency list from edges

DFS Traversal

Visit all nodes from root

Count Time

Add 2 seconds for each edge traversed

Code -

solution.c — C

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

int dfs(int node, int parent, int** graph, int* graphSize, int* hasApple) {
    int timeNeeded = 0;
    
    // Check all children
    for (int i = 0; i < graphSize[node]; i++) {
        int child = graph[node][i];
        if (child != parent) {
            int childTime = dfs(child, node, graph, graphSize, hasApple);
            // If child subtree has apples, we need to visit it
            if (childTime > 0 || hasApple[child]) {
                timeNeeded += childTime + 2; // 2 for going to child and back
            }
        }
    }
    
    return timeNeeded;
}

int solution(int n, int** edges, int edgesSize, int* hasApple) {
    if (n <= 1) return 0;
    
    // Build adjacency list
    int** graph = (int**)malloc(n * sizeof(int*));
    int* graphSize = (int*)calloc(n, sizeof(int));
    
    for (int i = 0; i < n; i++) {
        graph[i] = (int*)malloc(n * sizeof(int));
    }
    
    for (int i = 0; i < edgesSize; i++) {
        int u = edges[i][0], v = edges[i][1];
        graph[u][graphSize[u]++] = v;
        graph[v][graphSize[v]++] = u;
    }
    
    int result = dfs(0, -1, graph, graphSize, hasApple);
    
    for (int i = 0; i < n; i++) {
        free(graph[i]);
    }
    free(graph);
    free(graphSize);
    
    return result;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

void parseEdges(const char* str, int** edges, int* edgesSize) {
    *edgesSize = 0;
    if (strcmp(str, "[]") == 0) return;
    
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        if (*p == '[') {
            p++;
            int edgeCount = 0;
            int tempEdge[2];
            while (*p && *p != ']') {
                while (*p == ' ' || *p == ',') p++;
                if (*p == ']' || *p == '\0') break;
                tempEdge[edgeCount++] = (int)strtol(p, (char**)&p, 10);
            }
            if (edgeCount == 2) {
                edges[*edgesSize][0] = tempEdge[0];
                edges[*edgesSize][1] = tempEdge[1];
                (*edgesSize)++;
            }
            if (*p == ']') p++;
        } else {
            p++;
        }
    }
}

void parseHasApple(const char* str, int* hasApple, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        if (strncmp(p, "true", 4) == 0) {
            hasApple[(*size)++] = 1;
            p += 4;
        } else if (strncmp(p, "false", 5) == 0) {
            hasApple[(*size)++] = 0;
            p += 5;
        } else {
            p++;
        }
    }
}

int main() {
    int n;
    scanf("%d", &n);
    getchar(); // consume newline
    
    char edgesStr[10000], hasAppleStr[10000];
    fgets(edgesStr, sizeof(edgesStr), stdin);
    fgets(hasAppleStr, sizeof(hasAppleStr), stdin);
    
    // Remove newlines
    edgesStr[strcspn(edgesStr, "\n")] = 0;
    hasAppleStr[strcspn(hasAppleStr, "\n")] = 0;
    
    int** edges = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        edges[i] = (int*)malloc(2 * sizeof(int));
    }
    
    int* hasApple = (int*)malloc(n * sizeof(int));
    int edgesSize, hasAppleSize;
    
    parseEdges(edgesStr, edges, &edgesSize);
    parseHasApple(hasAppleStr, hasApple, &hasAppleSize);
    
    printf("%d\n", solution(n, edges, edgesSize, hasApple));
    
    for (int i = 0; i < n; i++) {
        free(edges[i]);
    }
    free(edges);
    free(hasApple);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case, we might visit each edge multiple times due to backtracking

⚠ Quadratic Growth

Space Complexity

O(n)

Adjacency list and recursion stack depth up to n

⚡ Linearithmic Space

89.2K Views

Medium Frequency

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

Brute Force - Visit All Paths — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler