update assignment 1 solution

Author: echooocc

02_activities/assignments/assignment_1.ipynb

@@ -21,17 +21,25 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 9,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2\n"
+     ]
+    }
+   ],
    "source": [
     "import hashlib\n",
     "\n",
     "def hash_to_range(input_string: str) -> int:\n",
     "     hash_object = hashlib.sha256(input_string.encode())\n",
     "     hash_int = int(hash_object.hexdigest(), 16)\n",
     "     return (hash_int % 3) + 1\n",
-    "input_string = \"your_first_name_here\"\n",
+    "input_string = \"fan\"\n",
     "result = hash_to_range(input_string)\n",
     "print(result)\n"
    ]
@@ -80,9 +88,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 10,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "ename": "IndentationError",
+     "evalue": "expected an indented block (2850872121.py, line 8)",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;36m  Cell \u001b[0;32mIn[10], line 8\u001b[0;36m\u001b[0m\n\u001b[0;31m    # TODO\u001b[0m\n\u001b[0m          ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m expected an indented block\n"
+     ]
+    }
+   ],
    "source": [
     "# Definition for a binary tree node.\n",
     "# class TreeNode(object):\n",
@@ -130,18 +147,31 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 27,
    "metadata": {},
    "outputs": [],
    "source": [
     "# Definition for a binary tree node.\n",
-    "# class TreeNode(object):\n",
-    "#     def __init__(self, val = 0, left = None, right = None):\n",
-    "#         self.val = val\n",
-    "#         self.left = left\n",
-    "#         self.right = right\n",
+    "from typing import List\n",
+    "\n",
+    "class TreeNode(object):\n",
+    "    def __init__(self, val = 0, left = None, right = None):\n",
+    "        self.val = val\n",
+    "        self.left = left\n",
+    "        self.right = right\n",
     "def bt_path(root: TreeNode) -> List[List[int]]:\n",
-    "  # TODO"
+    "  def dfs(node, path):\n",
+    "    if node:\n",
+    "      path.append(node.val)\n",
+    "      if not node.left and not node.right:\n",
+    "        res.append(path[:])\n",
+    "      else:\n",
+    "        dfs(node.left, path)\n",
+    "        dfs(node.right, path)\n",
+    "      path.pop()\n",
+    "  res = []\n",
+    "  dfs(root, [])\n",
+    "  return res"
    ]
   },
   {
@@ -201,12 +231,10 @@
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {},
-   "outputs": [],
    "source": [
-    "# Your answer here"
+    "Problem: Given a binary tree, I need to find all possible paths from the root node to the leaf nodes, each path should be represented as a list of node values, this is a DFS."
    ]
   },
   {
@@ -218,11 +246,52 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 20,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Your answer here"
+    "def test_bt_path(root: TreeNode, expected: List[str]):\n",
+    "    result = bt_path(root)\n",
+    "    if sorted(result) == sorted(expected):\n",
+    "        print(f\"Test passed! Expected {expected}\")\n",
+    "    else:\n",
+    "        print(f\"Test failed! Expected {expected}, but got {result}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Test passed! Expected [[5, 4], [5, 6, 7]]\n",
+      "Test passed! Expected [[10, 5, 3], [10, 5, 8], [10, 15, 12]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "root_example_3 = TreeNode(5)\n",
+    "root_example_3.left = TreeNode(4)\n",
+    "root_example_3.right = TreeNode(6)\n",
+    "root_example_3.right.left = TreeNode(7)\n",
+    "    \n",
+    "expected_example_3 = [[5,4], [5,6,7]]\n",
+    "test_bt_path(root_example_3, expected_example_3)\n",
+    "    \n",
+    "\n",
+    "root_example_4 = TreeNode(10)\n",
+    "root_example_4.left = TreeNode(5)\n",
+    "root_example_4.right = TreeNode(15)\n",
+    "root_example_4.left.left = TreeNode(3)\n",
+    "root_example_4.left.right = TreeNode(8)\n",
+    "root_example_4.right.left = TreeNode(12)\n",
+    "    \n",
+    "expected_example_4 = [[10, 5, 3], [10, 5, 8], [10, 15, 12]]\n",
+    "    \n",
+    "test_bt_path(root_example_4, expected_example_4)"
    ]
   },
   {
@@ -239,7 +308,19 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Your answer here"
+    "def bt_path(root: TreeNode) -> List[List[int]]:\n",
+    "  def dfs(node, path):\n",
+    "    if node:\n",
+    "      path.append(node.val)\n",
+    "      if not node.left and not node.right:\n",
+    "        res.append(path[:])\n",
+    "      else:\n",
+    "        dfs(node.left, path)\n",
+    "        dfs(node.right, path)\n",
+    "      path.pop()\n",
+    "  res = []\n",
+    "  dfs(root, [])\n",
+    "  return res"
    ]
   },
   {
@@ -251,12 +332,21 @@
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {},
-   "outputs": [],
    "source": [
-    "# Your answer here"
+    "-----------\n",
+    "The solution uses a recursive DFS to explore all paths from the root to the leaves. Here’s how it works:\n",
+    "- **DFS Helper Function**: dfs(node, path, res) takes:\n",
+    "    - node: Current node being processed.\n",
+    "    - path: A list storing the current path’s node values as strings.\n",
+    "    - res: The result list collecting all complete paths.\n",
+    "- **Base Case**: If node is None (empty subtree), return without doing anything.\n",
+    "- **Path Building**: Add the current node’s value to path. This tracks the sequence from root to the current node.\n",
+    "- **Leaf Check**: If the node has no left or right child (not node.left and not node.right), it’s a leaf. push to res []\n",
+    "- **Recursion**: Recursively call dfs on the left and right children to explore all possible paths.\n",
+    "- **Backtrack**: path.pop() backtracks by removing the last element from the path list, allowing the algorithm to go back to previous state and explore other paths.\n",
+    "-----------"
    ]
   },
   {
@@ -268,29 +358,50 @@
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {},
-   "outputs": [],
    "source": [
-    "# Your answer here"
+    "-----------\n",
+    "Time Complexity: O(N*logN). \n",
+    "- DFS Traversal: This solution visits each node exactly once, so the time complexity is (O(N)), where (N) is the number of nodes in the binary tree. \n",
+    "- Path Construct: For each path, we append and pop values from the path list, where LogN is the length of the path, and height of the tree (H).\n",
+    "- Overall time complexity remains (O(N * H))\n",
+    "\n",
+    "Space Complexity: O(N + H). \n",
+    "- Recursive Stack: The space complexity due to the recursive stack is (O(H)) where (H) is the height of the tree.\n",
+    "- Path List: We use a list path to store the current path, which can take up to the length of the longest path, i.e., (O(H)).\n",
+    "- Result List: The result list res stores all paths, and in the worst case, it could contain all possible paths from root to leaf nodes, which is (O(N)).\n",
+    "- Overall space complexity is (O(N + H)).\n",
+    "  \n",
+    "-----------"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "\n",
-    "-   Explain the thinking to an alternative solution (no coding required, but a classmate reading this should be able to code it up based off your text)\n"
+    "  -  Explain the thinking to an alternative solution (no coding required, but a classmate reading this should be able to code it up based off your text)\n"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {},
-   "outputs": [],
    "source": [
-    "# Your answer here"
+    "-----------\n",
+    "To solve this problem iteratively using a stack:\n",
+    "\n",
+    "1. Initialize Stack: Start with the root node, an empty path list.\n",
+    "2. Iterate While Stack is Not Empty:\n",
+    "   1. Pop the current node, its path, and whether it's a leaf from the stack.\n",
+    "   2. If the current node is a leaf, add the constructed path to the result list.\n",
+    "   3. If the current node has a right child, push it onto the stack with the updated path and mark it as not a leaf.\n",
+    "   4. If the current node has a left child, push it onto the stack with the updated path and mark it as not a leaf.\n",
+    "3. Return Result List: After processing all nodes, return the result list containing all paths.\n",
+    "\n",
+    "This iterative approach ensures that each node is visited exactly once and constructs the paths efficiently using a stack.\n",
+    "\n",
+    "-----------"
    ]
   },
   {
@@ -338,7 +449,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "dsi_participant",
    "language": "python",
    "name": "python3"
   },
@@ -352,7 +463,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.7"
+   "version": "3.9.7"
   }
  },
  "nbformat": 4,