Minimum Fuel Cost to Report to the Capital

Minimum Fuel Cost to Report to the Capital - Problem

Imagine a country with n cities connected by roads forming a tree structure (no cycles, exactly n-1 roads). The capital city is always city 0, and there's a crucial meeting happening there!

Each city has one representative who needs to travel to the capital for this important meeting. Every city also has one car with a fixed number of seats. Here's the catch: representatives can either:

🚗 Drive their own car
🤝 Carpool with other representatives to save fuel

The cost is simple: 1 liter of fuel per road traveled. Your mission is to find the minimum total fuel needed to get all representatives to the capital!

Key insight: Since it's a tree, there's only one path between any two cities, making this an optimal carpooling problem.

Input & Output

example_1.py — Small Tree

$ Input: roads = [[0,1],[0,2],[0,3]], seats = 5

› Output: 3

💡 Note: Each city (1,2,3) has 1 representative. Since each car has 5 seats, each representative can drive alone to the capital. Total fuel: 1+1+1 = 3 liters.

example_2.py — Carpooling Beneficial

$ Input: roads = [[3,1],[3,2],[1,0],[0,4],[0,5],[4,6]], seats = 2

› Output: 7

💡 Note: Representatives from cities 1,2,3 can carpool. From node 3: 3 people need 2 cars (ceil(3/2)=2). From nodes 4,5,6: each sends 1 car. Total: 2+1+1+1+1+1 = 7 liters.

example_3.py — Single Node

$ Input: roads = [], seats = 1

› Output: 0

💡 Note: Only the capital exists, so no travel is needed. Total fuel: 0 liters.

Constraints

1 ≤ n ≤ 10⁵
roads.length == n - 1
roads[i].length == 2
0 ≤ a_i, b_i < n
a_i ≠ b_i
roads represents a valid tree
1 ≤ seats ≤ 10⁵

Visualization

Tap to expand

Understanding the Visualization

Start from Headquarters

Begin at the capital (headquarters) and explore all branches

Process Furthest Branches

Visit the furthest office branches first (leaf nodes)

Count Employees

At each branch, count employees coming from all sub-branches

Optimize Carpools

Calculate minimum cars needed: ceil(employees / seats_per_car)

Merge Upward

Continue merging carpools as we move closer to headquarters

Key Takeaway

🎯 Key Insight: By processing the tree bottom-up, we naturally optimize carpooling at each level. People from deeper branches automatically share rides as they move toward the capital, minimizing total fuel consumption.

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28 Apple 22

The optimal solution uses DFS bottom-up traversal starting from the capital. We process children before parents, counting the total people in each subtree and calculating the minimum cars needed using ceil(people/seats). This naturally optimizes carpooling by consolidating people at each level before moving up the tree. Time: O(n), Space: O(n).

Common Approaches

Approach	Time	Space	Notes
✓ DFS Bottom-Up (Optimal)	O(n)	O(n)	Single DFS traversal calculating optimal carpooling from leaves to root
Brute Force (Try All Combinations)	O(2^n)	O(n)	Try all possible carpooling combinations using recursive exploration

DFS Bottom-Up (Optimal) — Algorithm Steps

Build adjacency list representation of the tree
Start DFS from capital city (node 0)
For each node, recursively process all children first
Count total people from all subtrees
Calculate minimum cars needed: ceil(people / seats)
Add fuel cost for cars traveling to parent
Return total people in subtree for parent's calculation

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at Capital

Begin DFS traversal from capital city (node 0)

Process Children

Recursively visit all children before processing current node

Count People

Sum up people from all subtrees plus current node's representative

Calculate Cars

Determine minimum cars needed: ceil(people / seats)

Add Fuel Cost

Add fuel cost for cars traveling to parent node

Code -

solution.c — C

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

struct Node {
    int* neighbors;
    int neighborCount;
};

long long totalFuel;

int dfs(int node, int parent, struct Node* graph, int seats) {
    // Count people in this subtree
    int peopleInSubtree = 1;
    
    // Process all children first
    for (int i = 0; i < graph[node].neighborCount; i++) {
        int neighbor = graph[node].neighbors[i];
        if (neighbor != parent) {
            peopleInSubtree += dfs(neighbor, node, graph, seats);
        }
    }
    
    // If not at capital, calculate cars needed
    if (node != 0) {
        int carsNeeded = (peopleInSubtree + seats - 1) / seats; // Ceiling division
        totalFuel += carsNeeded;
    }
    
    return peopleInSubtree;
}

long long minimumFuelCost(int** roads, int roadsSize, int seats) {
    if (roadsSize == 0) return 0;
    
    int n = roadsSize + 1;
    struct Node* graph = (struct Node*)calloc(n, sizeof(struct Node));
    
    // Initialize neighbors arrays
    for (int i = 0; i < n; i++) {
        graph[i].neighbors = (int*)malloc(n * sizeof(int));
        graph[i].neighborCount = 0;
    }
    
    // Build adjacency list
    for (int i = 0; i < roadsSize; i++) {
        int a = roads[i][0], b = roads[i][1];
        graph[a].neighbors[graph[a].neighborCount++] = b;
        graph[b].neighbors[graph[b].neighborCount++] = a;
    }
    
    totalFuel = 0;
    dfs(0, -1, graph, seats);
    
    // Cleanup
    for (int i = 0; i < n; i++) {
        free(graph[i].neighbors);
    }
    free(graph);
    
    return totalFuel;
}

int main() {
    int seats, roadsSize;
    scanf("%d %d", &seats, &roadsSize);
    
    int** roads = (int**)malloc(roadsSize * sizeof(int*));
    for (int i = 0; i < roadsSize; i++) {
        roads[i] = (int*)malloc(2 * sizeof(int));
        scanf("%d %d", &roads[i][0], &roads[i][1]);
    }
    
    printf("%lld\n", minimumFuelCost(roads, roadsSize, seats));
    
    for (int i = 0; i < roadsSize; i++) {
        free(roads[i]);
    }
    free(roads);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once during DFS traversal

✓ Linear Growth

Space Complexity

O(n)

Adjacency list storage plus recursion stack depth (at most n for skewed tree)

⚡ Linearithmic Space

76.2K Views

High Frequency

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

DFS Bottom-Up (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler