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

<p>There is a meeting for the representatives of each city. The meeting is in the capital city.</p>

<p>There is a car in each city. You are given an integer <code>seats</code> that indicates the number of seats in each car.</p>

<p>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.</p>

<p>Return <em>the minimum number of liters of fuel to reach the capital city</em>.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2022/09/22/a4c380025e3ff0c379525e96a7d63a3.png" style="width: 303px; height: 332px;" />
<pre>
<strong>Input:</strong> roads = [[0,1],[0,2],[0,3]], seats = 5
<strong>Output:</strong> 3
<strong>Explanation:</strong> 
- Representative<sub>1</sub> goes directly to the capital with 1 liter of fuel.
- Representative<sub>2</sub> goes directly to the capital with 1 liter of fuel.
- Representative<sub>3</sub> 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.
</pre>

<p><strong class="example">Example 2:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2022/11/16/2.png" style="width: 274px; height: 340px;" />
<pre>
<strong>Input:</strong> roads = [[3,1],[3,2],[1,0],[0,4],[0,5],[4,6]], seats = 2
<strong>Output:</strong> 7
<strong>Explanation:</strong> 
- Representative<sub>2</sub> goes directly to city 3 with 1 liter of fuel.
- Representative<sub>2</sub> and representative<sub>3</sub> go together to city 1 with 1 liter of fuel.
- Representative<sub>2</sub> and representative<sub>3</sub> go together to the capital with 1 liter of fuel.
- Representative<sub>1</sub> goes directly to the capital with 1 liter of fuel.
- Representative<sub>5</sub> goes directly to the capital with 1 liter of fuel.
- Representative<sub>6</sub> goes directly to city 4 with 1 liter of fuel.
- Representative<sub>4</sub> and representative<sub>6</sub> 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.
</pre>

<p><strong class="example">Example 3:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2022/09/27/efcf7f7be6830b8763639cfd01b690a.png" style="width: 108px; height: 86px;" />
<pre>
<strong>Input:</strong> roads = [], seats = 1
<strong>Output:</strong> 0
<strong>Explanation:</strong> No representatives need to travel to the capital city.
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>1 &lt;= n &lt;= 10<sup>5</sup></code></li>
	<li><code>roads.length == n - 1</code></li>
	<li><code>roads[i].length == 2</code></li>
	<li><code>0 &lt;= a<sub>i</sub>, b<sub>i</sub> &lt; n</code></li>
	<li><code>a<sub>i</sub> != b<sub>i</sub></code></li>
	<li><code>roads</code> represents a valid tree.</li>
	<li><code>1 &lt;= seats &lt;= 10<sup>5</sup></code></li>
</ul>

class Solution:
    def minimumFuelCost(self, roads: List[List[int]], seats: int) -> int:
        graph, degree = self.get_adj_list(roads)
        rep_count = [1]*(len(roads)+1)
        q = []
        for i in range(len(degree)):
            if degree[i] == 1 and i > 0:
                q.append(i)

        fuel = 0
        while q:
            node = q.pop(0)
            # print("->",node, fuel, rep_count, degree)
            # if node == 0:
                # continue

            neighbour = graph.get(node)
            # print(neighbour)
            if len(neighbour) == 0:
                continue
            next_city = list(neighbour)[0]
            graph[next_city].remove(node) # take the edge out
            degree[next_city] -= 1
            if degree[next_city] == 1 and next_city != 0:
                q.append(next_city)
            node_rep_count = rep_count[node]
            cars_needed = node_rep_count // seats
            if node_rep_count % seats > 0:
                cars_needed += 1
            # cars_needed += node_rep_count % seats
            rep_count[node] = 0
            rep_count[next_city] += node_rep_count
            fuel += cars_needed

        return fuel
    
    def get_adj_list(self, edges):
        graph = {}
        degree = [0]*(len(edges)+1)
        for e in edges:
            src, tgt = e[0], e[1]
            srcconn = graph.get(src, set())
            tgtconn = graph.get(tgt, set())
            srcconn.add(tgt)
            tgtconn.add(src)
            graph[src] = srcconn
            graph[tgt] = tgtconn
            degree[src] += 1
            degree[tgt] += 1
        return graph, degree


# there's is a car in each city
# we don't need to use the car in each city
# the graph is a tree, meaning there's no cycles and exactly 1 way from nodes to root

# what about running DFS from each leaf and getting as much representatives possible?
# when we take a representative we mark the node as visited
# meaning we won't run DFS from it

# DFS from the leafs first! (degree == 1)
# when we take representative from city, its degree reduces the degrees of its neighbour cities by 1
# when degree == 1 we insert in the DFS queue!

# we need adj_list which will also count degree
# we iterate degree, every node with 1 degree enters the DFS queue
# is there a order to start?
# we start DFS for all nodes in the queue
# we only run DFS if node is not visited
# but we still cut the degree of its neighbours!
# we take representative (mark as visited) if seats > 0
# we stop when node.val == 0: return 0
# every DFS run we return explore + 1

# graph is a hashmap of values pointing to a hashset of neighbour nodes


# the best strategy apparently is not run DFS from leaf to root
# is to accumulate representatives in the cities, making them leafs first
# and then running the algorithm

# leaf? -> run DFS to accumulate you in the next leaf node
# remove the connection from that new leaf to current leaf we just ran
# increment amount of representatives in that node
# update degree, if d == 1 add it to queue


# amount_of_cars = number_of_representatives_in_node // seats
# if representatives % seats == 1: amount_of_cars += 1
# we add result += amount_of_cars and move it to the next city!

# we need an array keeping amount of representatives in each node
# everything starts with 1
# we need a adj_list with values being hashset
# we need a degree array1
69488