"""
There is a tree (i.e., a connected, undirected graph with no cycles) structure country network consisting of n cities numbered from 0 to n - 1 and exactly n - 1 roads. The capital city is city 0. You are given a 2D integer array roads where roads[i] = [ai, bi] denotes that there exists a bidirectional road connecting cities ai and bi.

There is a meeting for the representatives of each city. The meeting is in the capital city.

There is a car in each city. You are given an integer seats that indicates the number of seats in each car.

A representative can use the car in their city to travel or change the car and ride with another representative. The cost of traveling between two cities is one liter of fuel.

Return the minimum number of liters of fuel to reach the capital city.

Example 1:
Input: roads = [[0,1],[0,2],[0,3]], seats = 5
Output: 3
Explanation:
- Representative1 goes directly to the capital with 1 liter of fuel.
- Representative2 goes directly to the capital with 1 liter of fuel.
- Representative3 goes directly to the capital with 1 liter of fuel.
It costs 3 liters of fuel at minimum.
It can be proven that 3 is the minimum number of liters of fuel needed.

Example 2:
Input: roads = [[3,1],[3,2],[1,0],[0,4],[0,5],[4,6]], seats = 2
Output: 7
Explanation:
- Representative2 goes directly to city 3 with 1 liter of fuel.
- Representative2 and representative3 go together to city 1 with 1 liter of fuel.
- Representative2 and representative3 go together to the capital with 1 liter of fuel.
- Representative1 goes directly to the capital with 1 liter of fuel.
- Representative5 goes directly to the capital with 1 liter of fuel.
- Representative6 goes directly to city 4 with 1 liter of fuel.
- Representative4 and representative6 go together to the capital with 1 liter of fuel.
It costs 7 liters of fuel at minimum.
It can be proven that 7 is the minimum number of liters of fuel needed.
Example 3:


Input: roads = [], seats = 1
Output: 0
Explanation: No representatives need to travel to the capital city.


Constraints:
1 <= n <= 10^5
roads.length == n - 1
roads[i].length == 2
0 <= ai, bi < n
ai != bi
roads represents a valid tree.
1 <= seats <= 10^5

hints:
1 Can you record the size of each subtree?
2 If n people meet on the same node, what is the minimum number of cars needed?

analysis:
track the number of people that reach each node and divide that by the number of seats per car,
this indicates number of cars required to take people pass this node
TC: O(N)
"""
from collections import defaultdict, deque
import math
from typing import List


class Solution:
    def minimumFuelCost(self, roads: List[List[int]], seats: int) -> int:
        self.res = 0
        graph = collections.defaultdict(list)
        for a, b in roads:
            graph[a].append(b)
            graph[b].append(a)

        def dfs(cur, pre):
            people = 1
            for nb in graph[cur]:
                if nb != pre:
                    people += dfs(nb, cur)
            self.res += int(math.ceil(people / seats)) if cur else 0
            return people

        dfs(0, -1)
        return self.res

    def minimumFuelCostBFS(self, roads: List[List[int]], seats: int) -> int:
        res = 0
        cities = len(roads) + 1
        representatives = [1] * cities
        graph = defaultdict(list)
        degree = [0] * cities
        for a, b in roads:
            graph[a].append(b)
            graph[b].append(a)
            degree[a] += 1
            degree[b] += 1
        q = deque()
        for i in range(1, cities):
            if degree[i] == 1:
                q.append(i)
        while q:
            cur = q.popleft()
            res += math.ceil(representatives[cur] / seats)
            for nb in graph[cur]:
                degree[nb] -= 1
                representatives[nb] += representatives[cur]
                if degree[nb] == 1 and nb != 0:
                    q.append(nb)
        return res










