feat: complete minimum_height_trees

Author: wislertt

.templates/leetcode/json/clone_graph.json

@@ -37,14 +37,14 @@
     "test_methods": [
         {
             "name": "test_clone_graph",
-            "parametrize": "adj_list, expected_adj_list",
-            "parametrize_typed": "adj_list: list[list[int]], expected_adj_list: list[list[int]]",
-            "test_cases": "[([[2,4],[1,3],[2,4],[1,3]], [[2,4],[1,3],[2,4],[1,3]]), ([[]], [[]]), ([], [])]",
-            "body": "node = GraphNode.from_adjacency_list(adj_list)\nexpected = GraphNode.from_adjacency_list(expected_adj_list)\nresult = self.solution.clone_graph(node)\nassert GraphNode.to_adjacency_list(result) == GraphNode.to_adjacency_list(expected)"
+            "parametrize": "adj_list",
+            "parametrize_typed": "adj_list: list[list[int]]",
+            "test_cases": "[[[2, 4], [1, 3], [2, 4], [1, 3]], [[]], []]",
+            "body": "node = GraphNode.from_adjacency_list(adj_list)\nresult = self.solution.clone_graph(node)\nassert result.is_clone(node) if result else node is None"
         }
     ],
     "playground_imports": "from solution import Solution\n\nfrom leetcode_py import GraphNode",
-    "playground_test_case": "# Example test case\nadj_list = [[2,4],[1,3],[2,4],[1,3]]\nnode = GraphNode.from_adjacency_list(adj_list)\nexpected_adj_list = [[2,4],[1,3],[2,4],[1,3]]",
-    "playground_execution": "result = Solution().clone_graph(node)\nGraphNode.to_adjacency_list(result)",
-    "playground_assertion": "assert GraphNode.to_adjacency_list(result) == expected_adj_list"
+    "playground_test_case": "# Example test case\nadj_list = [[2,4],[1,3],[2,4],[1,3]]\nnode = GraphNode.from_adjacency_list(adj_list)",
+    "playground_execution": "result = Solution().clone_graph(node)\nresult",
+    "playground_assertion": "assert result.is_clone(node) if result else node is None"
 }

.templates/leetcode/json/minimum_height_trees.json

@@ -0,0 +1,47 @@
+{
+    "problem_name": "minimum_height_trees",
+    "solution_class_name": "Solution",
+    "problem_number": "310",
+    "problem_title": "Minimum Height Trees",
+    "difficulty": "Medium",
+    "topics": "Depth-First Search, Breadth-First Search, Graph, Topological Sort",
+    "tags": [],
+    "readme_description": "A tree is an undirected graph in which any two vertices are connected by *exactly* one path. In other words, any connected graph without simple cycles is a tree.\n\nGiven a tree of `n` nodes labelled from `0` to `n - 1`, and an array of `n - 1` `edges` where `edges[i] = [ai, bi]` indicates that there is an undirected edge between the two nodes `ai` and `bi` in the tree, you can choose any node of the tree as the root. When you select a node `x` as the root, the result tree has height `h`. Among all possible rooted trees, those with minimum height (i.e. `min(h)`) are called **minimum height trees** (MHTs).\n\nReturn *a list of all **MHTs'** root labels*. You can return the answer in **any order**.\n\nThe **height** of a rooted tree is the number of edges on the longest downward path between the root and a leaf.",
+    "readme_examples": [
+        {
+            "content": "<img alt=\"\" src=\"https://assets.leetcode.com/uploads/2020/09/01/e1.jpg\" style=\"width: 800px; height: 213px;\" />\n\n```\nInput: n = 4, edges = [[1,0],[1,2],[1,3]]\nOutput: [1]\nExplanation: As shown, the height of the tree is 1 when the root is the node with label 1 which is the only MHT.\n```"
+        },
+        {
+            "content": "<img alt=\"\" src=\"https://assets.leetcode.com/uploads/2020/09/01/e2.jpg\" style=\"width: 800px; height: 321px;\" />\n\n```\nInput: n = 6, edges = [[3,0],[3,1],[3,2],[3,4],[5,4]]\nOutput: [3,4]\n```"
+        }
+    ],
+    "readme_constraints": "- `1 <= n <= 2 * 10^4`\n- `edges.length == n - 1`\n- `0 <= ai, bi < n`\n- `ai != bi`\n- All the pairs `(ai, bi)` are distinct.\n- The given input is **guaranteed** to be a tree and there will be **no repeated** edges.",
+    "readme_additional": "",
+    "solution_imports": "",
+    "solution_methods": [
+        {
+            "name": "find_min_height_trees",
+            "parameters": "n: int, edges: list[list[int]]",
+            "return_type": "list[int]",
+            "dummy_return": "[]"
+        }
+    ],
+    "test_imports": "import pytest\nfrom leetcode_py.test_utils import logged_test\nfrom .solution import Solution",
+    "test_class_name": "MinimumHeightTrees",
+    "test_helper_methods": [
+        { "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }
+    ],
+    "test_methods": [
+        {
+            "name": "test_find_min_height_trees",
+            "parametrize": "n, edges, expected",
+            "parametrize_typed": "n: int, edges: list[list[int]], expected: list[int]",
+            "test_cases": "[(4, [[1,0],[1,2],[1,3]], [1]), (6, [[3,0],[3,1],[3,2],[3,4],[5,4]], [3,4]), (1, [], [0])]",
+            "body": "result = self.solution.find_min_height_trees(n, edges)\nassert sorted(result) == sorted(expected)"
+        }
+    ],
+    "playground_imports": "from solution import Solution",
+    "playground_test_case": "# Example test case\nn = 4\nedges = [[1,0],[1,2],[1,3]]\nexpected = [1]",
+    "playground_execution": "result = Solution().find_min_height_trees(n, edges)\nresult",
+    "playground_assertion": "assert sorted(result) == sorted(expected)"
+}

Makefile

@@ -1,5 +1,5 @@
 PYTHON_VERSION = 3.13
-PROBLEM ?= clone_graph
+PROBLEM ?= minimum_height_trees
 FORCE ?= 0
 
 sync_submodules:

leetcode/clone_graph/playground.ipynb

@@ -181,10 +181,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "if result is None:\n",
-    "    assert node is None\n",
-    "else:\n",
-    "    assert result.is_clone(node)"
+    "assert result.is_clone(node) if result else node is None"
    ]
   }
  ],

leetcode/clone_graph/tests.py

@@ -22,7 +22,4 @@ def test_clone_graph(
         node = GraphNode.from_adjacency_list(adj_list)
         result = solution.clone_graph(node)
 
-        if result is None:
-            assert node is None
-        else:
-            assert result.is_clone(node)
+        assert result.is_clone(node) if result else node is None

leetcode/minimum_height_trees/README.md

@@ -0,0 +1,47 @@
+# Minimum Height Trees
+
+**Difficulty:** Medium
+**Topics:** Depth-First Search, Breadth-First Search, Graph, Topological Sort
+**Tags:**
+
+**LeetCode:** [Problem 310](https://leetcode.com/problems/minimum-height-trees/description/)
+
+## Problem Description
+
+A tree is an undirected graph in which any two vertices are connected by _exactly_ one path. In other words, any connected graph without simple cycles is a tree.
+
+Given a tree of `n` nodes labelled from `0` to `n - 1`, and an array of `n - 1` `edges` where `edges[i] = [ai, bi]` indicates that there is an undirected edge between the two nodes `ai` and `bi` in the tree, you can choose any node of the tree as the root. When you select a node `x` as the root, the result tree has height `h`. Among all possible rooted trees, those with minimum height (i.e. `min(h)`) are called **minimum height trees** (MHTs).
+
+Return _a list of all **MHTs'** root labels_. You can return the answer in **any order**.
+
+The **height** of a rooted tree is the number of edges on the longest downward path between the root and a leaf.
+
+## Examples
+
+### Example 1:
+
+<img alt="" src="https://assets.leetcode.com/uploads/2020/09/01/e1.jpg" style="width: 800px; height: 213px;" />
+
+```
+Input: n = 4, edges = [[1,0],[1,2],[1,3]]
+Output: [1]
+Explanation: As shown, the height of the tree is 1 when the root is the node with label 1 which is the only MHT.
+```
+
+### Example 2:
+
+<img alt="" src="https://assets.leetcode.com/uploads/2020/09/01/e2.jpg" style="width: 800px; height: 321px;" />
+
+```
+Input: n = 6, edges = [[3,0],[3,1],[3,2],[3,4],[5,4]]
+Output: [3,4]
+```
+
+## Constraints
+
+- `1 <= n <= 2 * 10^4`
+- `edges.length == n - 1`
+- `0 <= ai, bi < n`
+- `ai != bi`
+- All the pairs `(ai, bi)` are distinct.
+- The given input is **guaranteed** to be a tree and there will be **no repeated** edges.

leetcode/minimum_height_trees/__init__.py

@@ -0,0 +1,80 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "imports",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from solution import Solution"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "setup",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Example test case\n",
+    "n = 4\n",
+    "edges = [[1, 0], [1, 2], [1, 3]]\n",
+    "expected = [1]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "execute",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[1]"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "result = Solution().find_min_height_trees(n, edges)\n",
+    "result"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "test",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "assert sorted(result) == sorted(expected)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "leetcode-py-py3.13",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.13.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

leetcode/minimum_height_trees/playground.ipynb

@@ -0,0 +1,29 @@
+from collections import defaultdict, deque
+
+
+class Solution:
+    # Time: O(V)
+    # Space: O(V)
+    def find_min_height_trees(self, n: int, edges: list[list[int]]) -> list[int]:
+        if n == 1:
+            return [0]
+
+        graph = defaultdict(set)
+        for u, v in edges:
+            graph[u].add(v)
+            graph[v].add(u)
+
+        leaves = deque([i for i in range(n) if len(graph[i]) == 1])
+
+        remaining = n
+        while remaining > 2:
+            size = len(leaves)
+            remaining -= size
+            for _ in range(size):
+                leaf = leaves.popleft()
+                neighbor = graph[leaf].pop()
+                graph[neighbor].remove(leaf)
+                if len(graph[neighbor]) == 1:
+                    leaves.append(neighbor)
+
+        return list(leaves)

leetcode/minimum_height_trees/solution.py

@@ -0,0 +1,23 @@
+import pytest
+
+from leetcode_py.test_utils import logged_test
+
+from .solution import Solution
+
+
+class TestMinimumHeightTrees:
+    def setup_method(self):
+        self.solution = Solution()
+
+    @pytest.mark.parametrize(
+        "n, edges, expected",
+        [
+            (4, [[1, 0], [1, 2], [1, 3]], [1]),
+            (6, [[3, 0], [3, 1], [3, 2], [3, 4], [5, 4]], [3, 4]),
+            (1, [], [0]),
+        ],
+    )
+    @logged_test
+    def test_find_min_height_trees(self, n: int, edges: list[list[int]], expected: list[int]):
+        result = self.solution.find_min_height_trees(n, edges)
+        assert sorted(result) == sorted(expected)