<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 {
public:
    long long dfsTraversal(unordered_map<int, vector<int>> & record_map, int & seats, int node_val, int prev_node_val, long long & res_min_cnter)
    {
        //=======================================================================//
        // Input type:                                                           //
        //   - unordered_map<int, vector<int>> ref. (record dictionary, hashmap) //
        //   - int ref. (total seats)                                            //
        //   - int (current node value)                                          //
        //   - int (previous node value)                                         //
        //   - long long ref. (result minimun summary counter)                   //
        // Return type:                                                          //
        //   - long long (result minimun summary counter)                        //
        //=======================================================================//

        /*Initialize*/
        ///// Result people, representations /////
        long long res_people = 1;

        /*Whole process, flow*/
        for (int sub_val: record_map[node_val]) //Whole
        {
            ///// Check if the current indexed-value is previous or not /////
            if (sub_val == prev_node_val) { continue; }
            else
            {
                res_people += dfsTraversal(record_map, seats, sub_val, node_val, res_min_cnter); //Recursion function call
            }

        } //Whole

        ///// Check if the current node-value is capital type or not /////
        if (node_val)
        {
            ///// Check if the current divisions matched conditions or not /////
            if ((res_people % seats)) { res_min_cnter += ((res_people / seats) + 1); } //Update, Accumulate
            else { res_min_cnter += (res_people / seats); } //Update, Accumulate
        }

        else { ; }

        return res_people;
    }


    long long minimumFuelCost(vector<vector<int>> & roads, int seats) 
    {
        //================================================//
        // Input type:                                    //
        //   - vector<vector<int>> ref. (roads vector)    //
        //   - int (total seats)                          //
        // Return type:                                   //
        //   - long long (result minimun summary counter) //
        //================================================//
        if (! (roads.size())) { return 0; } //Issue, Boundary-case handling

        /*Initialize*/
        ///// Length of roads vector /////
        int len_roads = roads.size();

        ///// Record main, sub-node values /////
        int record_main_node_val, record_sub_node_val;

        ///// Record dictionary, hashmap /////
        unordered_map<int, vector<int>> record_map;

        ///// Result minimun summary counter /////
        long long res_min_cnter = 0;


        /*Recursion-based DFS loop traversal with recorded dictionary, hashmap*/
        ///// Step 1: Record indexed-value with dictionary, hashmap /////
        for (int roads_idx = 0; (roads_idx < len_roads); (roads_idx++)) //Whole
        {
            record_main_node_val = (roads[roads_idx])[0]; //Record main-node value
            record_sub_node_val = (roads[roads_idx])[1]; //Record sub-node value

            (record_map[record_main_node_val]).push_back(record_sub_node_val); //Keep updating, recording
            (record_map[record_sub_node_val]).push_back(record_main_node_val); //Keep updating, recording

        } //Whole

        ///// Step 2: Looped-traversal with recorded hashmap /////
        int res_people = dfsTraversal(record_map, seats, 0, (-1), res_min_cnter); //Resursion function call

        return res_min_cnter;
    }
};
225019