{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Queue / Fronta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "queue = [\"a\", \"b\", \"c\", \"d\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'d'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "queue.pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'b', 'c']"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "queue"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reprezentácia grafu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Optional"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_graph = {\n",
    "    'A': ['B', 'C'],\n",
    "    'B': ['A','D','E'],\n",
    "    'C': ['A','F'],\n",
    "    'D': ['B','G'],\n",
    "    'E': ['B','G'],\n",
    "    'F': ['C','G'],\n",
    "    'G': ['D','E','F']\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['B', 'C']"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_graph[\"A\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "B\n",
      "C\n"
     ]
    }
   ],
   "source": [
    "for neighbor in my_graph[\"A\"]:\n",
    "    print(neighbor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "start_node = \"A\"\n",
    "goal_node = \"G\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "def search(graph: dict[str, list[str]], start: str, goal: str) -> Optional[dict[str, str]]:\n",
    "    fifo = [start]\n",
    "    visited = {start: None}\n",
    "\n",
    "    while fifo:\n",
    "        current_node = fifo.pop(0)\n",
    "\n",
    "        if current_node == goal:    \n",
    "            return visited\n",
    "        \n",
    "        for neighbor in graph[current_node]:\n",
    "            if neighbor not in visited:\n",
    "                visited[neighbor] = current_node\n",
    "                fifo.append(neighbor)\n",
    "\n",
    "    return None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'A': None, 'B': 'A', 'C': 'A', 'D': 'B', 'E': 'B', 'F': 'C', 'G': 'D'}"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "search(my_graph, start_node, goal_node)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "def search(graph: dict[str, list[str]], start: str, goal: str) -> Optional[dict[str, str]]:\n",
    "    fifo = [start]\n",
    "    visited = {start: None}\n",
    "\n",
    "    while fifo:\n",
    "        current_node = fifo.pop(0)\n",
    "\n",
    "        if current_node == goal:    \n",
    "            return visited\n",
    "        \n",
    "        for neighbor in graph[current_node]:\n",
    "            if neighbor not in visited:\n",
    "                visited[neighbor] = current_node\n",
    "                print(visited)\n",
    "                fifo.append(neighbor)\n",
    "\n",
    "    return None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'A': None, 'B': 'A'}\n",
      "{'A': None, 'B': 'A', 'C': 'A'}\n",
      "{'A': None, 'B': 'A', 'C': 'A', 'D': 'B'}\n",
      "{'A': None, 'B': 'A', 'C': 'A', 'D': 'B', 'E': 'B'}\n",
      "{'A': None, 'B': 'A', 'C': 'A', 'D': 'B', 'E': 'B', 'F': 'C'}\n",
      "{'A': None, 'B': 'A', 'C': 'A', 'D': 'B', 'E': 'B', 'F': 'C', 'G': 'D'}\n"
     ]
    }
   ],
   "source": [
    "result = search(my_graph, start_node, goal_node)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "def reconstruct_path(visited: dict[str, str], start: str, goal: str) -> tuple[int, str]:\n",
    "    steps = 0\n",
    "    path = \"\"\n",
    "    current = goal\n",
    "\n",
    "    while current is not None:\n",
    "        path = current + \" -> \" + path\n",
    "        current = visited[current]\n",
    "        steps += 1\n",
    "    \n",
    "    path = path.removesuffix(\" -> \")\n",
    "    return steps, path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "steps, path = reconstruct_path(result, start_node, goal_node)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "steps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'A -> B -> D -> G'"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "path"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prehľadávanie do šírky + nájdenie najkratšej cesty"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "import heapq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [3, 5, 1, 2, 6, 8, 7]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "heapq.heapify(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 5, 6, 8, 7]"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [2, 5, 3, 7, 6, 8]\n",
    "heapq.heappush(a, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 5, 3, 7, 6, 8, 4]"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "heapq.heappop(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "heapq.heappop(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Uniform cost search"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```mermaid\n",
    "flowchart LR\n",
    "    A<-->|4|C;\n",
    "    A<-->|1|B;\n",
    "    B<-->|1|D;\n",
    "    B<-->|3|E;\n",
    "    D<-->|4|G;\n",
    "    E<-->|1|G;\n",
    "    C<-->|2|F;\n",
    "    G<-->|2|F;\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_graph = {\n",
    "    'A': [('B', 1), ('C', 4)],\n",
    "    'B': [('A',1), ('D', 1), ('E', 3)],\n",
    "    'C': [('A', 4), ('F', 2)],\n",
    "    'D': [('B', 1), ('G', 4)],\n",
    "    'E': [('B', 3), ('G', 1)],\n",
    "    'F': [('C', 2), ('G', 2)],\n",
    "    'G': [('D', 4), ('E', 1), ('F', 2)]\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [],
   "source": [
    "def reconstruct_path(visited: dict[str, tuple[int, str]], start: str, goal: str) -> str:\n",
    "    path = []\n",
    "    current = goal\n",
    "    while current is not None:\n",
    "        path.append(current)\n",
    "        current = visited[current][1]\n",
    "    path.reverse()\n",
    "    return path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [],
   "source": [
    "def uniform_cost_search(graph: dict[str, list[tuple[str, int]]], start: str, goal: str) -> Optional[str]:\n",
    "    priority_queue = [(0, start)]\n",
    "    visited = {start: (0, None)}\n",
    "\n",
    "    while priority_queue:\n",
    "        current_cost, current_node = heapq.heappop(priority_queue)\n",
    "\n",
    "        if current_node == goal:\n",
    "            return current_cost, reconstruct_path(visited, start, goal)\n",
    "        \n",
    "        for neighbor, cost in graph[current_node]:\n",
    "            total_cost = current_cost + cost\n",
    "\n",
    "            if neighbor not in visited or total_cost < visited[neighbor][0]:\n",
    "                visited[neighbor] = (total_cost, current_node)\n",
    "                heapq.heappush(priority_queue, (total_cost, neighbor))\n",
    "\n",
    "    return None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [],
   "source": [
    "result = uniform_cost_search(my_graph, start_node, goal_node)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Least cost path from A to G: A -> B -> E -> G with total cost 5\n"
     ]
    }
   ],
   "source": [
    "if result:\n",
    "    total_cost, path = result\n",
    "    print(f\"Least cost path from {start_node} to {goal_node}: {' -> '.join(path)} with total cost {total_cost}\")\n",
    "else:\n",
    "    print(f\"No path found from {start_node} to {goal_node}\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "ui-cviko1",
   "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}