Depth-First Search and Breadth-First Search in Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Depth-First Search and Breadth-First Search in Python\n",
    "\n",
    "By Edd Mann\n",
    "\n",
    "Source: https://eddmann.com/posts/depth-first-search-and-breadth-first-search-in-python/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Graph theory and in particular the graph ADT (abstract data-type) is widely explored and implemented in the field of Computer Science and Mathematics. Consisting of vertices (nodes) and the edges (optionally directed/weighted) that connect them, the data-structure is effectively able to represent and solve many problem domains. One of the most popular areas of algorithm design within this space is the problem of checking for the existence or (shortest) path between two or more vertices in the graph. Properties such as edge weighting and direction are two such factors that the algorithm designer can take into consideration. In this post I will be exploring two of the simpler available algorithms, Depth-First and Breath-First search to achieve the goals highlighted below:\n",
    "\n",
    "- Find all vertices in a subject vertices connected component.\n",
    "- Return all available paths between two vertices.\n",
    "- And in the case of BFS, return the shortest path (length measured by number of path edges).\n",
    "\n",
    "# The Graph\n",
    "\n",
    "So as to clearly discuss each algorithm I have crafted a connected graph with six vertices and six incident edges. The resulting graph is undirected with no assigned edge weightings, as length will be evaluated based on the number of path edges traversed. There are two popular options for representing a graph, the first being an adjacency matrix (effective with dense graphs) and second an adjacency list (effective with sparse graphs). I have opted to implement an adjacency list which stores each node in a dictionary along with a set containing their adjacent nodes. As the graph is undirected each edge is stored in both incident nodes adjacent sets.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "graph = {'A': set(['B', 'C']),\n",
    "         'B': set(['A', 'D', 'E']),\n",
    "         'C': set(['A', 'F']),\n",
    "         'D': set(['B']),\n",
    "         'E': set(['B', 'F']),\n",
    "         'F': set(['C', 'E'])}"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Looking at the graph depiction below you will also notice the inclusion of a cycle, by the adjacent connections between ‘F’ and ‘C/E’. This has been purposely included to provide the algorithms with the option to return multiple paths between two desired nodes.\n",
    "\n",
    "![image.png](attachment:image.png)\n",
    "\n",
    "# Depth-First Search\n",
    "\n",
    "The first algorithm I will be discussing is Depth-First search which as the name hints at, explores possible vertices (from a supplied root) down each branch before backtracking. This property allows the algorithm to be implemented succinctly in both iterative and recursive forms. Below is a listing of the actions performed upon each visit to a node.\n",
    "\n",
    "- Mark the current vertex as being visited.\n",
    "- Explore each adjacent vertex that is not included in the visited set."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Connected Component\n",
    "\n",
    "The implementation below uses the stack data-structure to build-up and return a set of vertices that are accessible within the subjects connected component. Using Python’s overloading of the subtraction operator to remove items from a set, we are able to add only the unvisited adjacent vertices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'A', 'B', 'C', 'D', 'E', 'F'}"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def dfs(graph, start):\n",
    "    visited, stack = set(), [start] # ❌ Because set() is not ordered, the order of node visits is lost.\n",
    "    while stack:\n",
    "        vertex = stack.pop()\n",
    "        if vertex not in visited:\n",
    "            visited.add(vertex)\n",
    "            stack.extend(graph[vertex] - visited)\n",
    "    return visited\n",
    "\n",
    "dfs(graph, 'A') # {'E', 'D', 'F', 'A', 'C', 'B'} ❌ Not code result, or correct for algorithm\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['A', 'B', 'E', 'F', 'C', 'D']"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ✅ Fixed?\n",
    "\n",
    "def dfs(graph, start):\n",
    "    visited, stack = [], [start] # ✅ Use list\n",
    "    while stack:\n",
    "        vertex = stack.pop()\n",
    "        if vertex not in visited:\n",
    "            visited.append(vertex)\n",
    "            stack.extend(graph[vertex] - set(visited)) # ✅ Convert to set()\n",
    "    return visited\n",
    "\n",
    "dfs(graph, 'A') # ['A', 'B', 'E', 'F', 'C', 'D'] # Correct output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The second implementation provides the same functionality as the first, however, this time we are using the more succinct recursive form. Due to a common Python gotcha with default parameter values being created only once, we are required to create a new visited set on each user invocation. Another Python language detail is that function variables are passed by reference, resulting in the visited mutable set not having to reassigned upon each recursive call.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'A', 'B', 'C', 'D', 'E', 'F'}"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def dfs(graph, start, visited=None):\n",
    "    if visited is None:\n",
    "        visited = set() # ❌ Because set() is not ordered, the order of node visits is lost.\n",
    "    visited.add(start)\n",
    "    for next in graph[start] - visited:\n",
    "        dfs(graph, next, visited)\n",
    "    return visited\n",
    "\n",
    "dfs(graph, 'C') # {'E', 'D', 'F', 'A', 'C', 'B'} ❌ Does not match output, and output incorrect\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['C', 'F', 'E', 'B', 'A', 'D', 'A']"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ✅ Fixed?\n",
    "\n",
    "def dfs(graph, start, visited=[]): # ✅ Use list\n",
    "    visited.append(start)\n",
    "    for next in graph[start] - set(visited): # ✅ Convert to set()\n",
    "        dfs(graph, next, visited)\n",
    "    return visited\n",
    "\n",
    "dfs(graph, 'C') # ['C', 'F', 'E', 'B', 'A', 'D', 'A']\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Paths\n",
    "\n",
    "We are able to tweak both of the previous implementations to return all possible paths between a start and goal vertex. The implementation below uses the stack data-structure again to iteratively solve the problem, yielding each possible path when we locate the goal. Using a generator allows the user to only compute the desired amount of alternative paths.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['A', 'B', 'E', 'F'], ['A', 'C', 'F']]"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def dfs_paths(graph, start, goal):\n",
    "    stack = [(start, [start])]\n",
    "    while stack:\n",
    "        (vertex, path) = stack.pop()\n",
    "        for next in graph[vertex] - set(path):\n",
    "            if next == goal:\n",
    "                yield path + [next]\n",
    "            else:\n",
    "                stack.append((next, path + [next]))\n",
    "\n",
    "list(dfs_paths(graph, 'A', 'F')) # [['A', 'C', 'F'], ['A', 'B', 'E', 'F']] ⚠️ Correct, but order is different\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The implementation below uses the recursive approach calling the ‘yield from’ PEP380 addition to return the invoked located paths. Unfortunately the version of Pygments installed on the server at this time does not include the updated keyword combination."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['C', 'F'], ['C', 'A', 'B', 'E', 'F']]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def dfs_paths(graph, start, goal, path=None):\n",
    "    if path is None:\n",
    "        path = [start]\n",
    "    if start == goal:\n",
    "        yield path\n",
    "    for next in graph[start] - set(path):\n",
    "        yield from dfs_paths(graph, next, goal, path + [next])\n",
    "\n",
    "list(dfs_paths(graph, 'C', 'F')) # [['C', 'F'], ['C', 'A', 'B', 'E', 'F']]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Breath-First Search\n",
    "\n",
    "An alternative algorithm called Breath-First search provides us with the ability to return the same results as DFS but with the added guarantee to return the shortest-path first. This algorithm is a little more tricky to implement in a recursive manner instead using the queue data-structure, as such I will only being documenting the iterative approach. The actions performed per each explored vertex are the same as the depth-first implementation, however, replacing the stack with a queue will instead explore the breadth of a vertex depth before moving on. This behavior guarantees that the first path located is one of the shortest-paths present, based on number of edges being the cost factor.\n",
    "\n",
    "Connected Component\n",
    "Similar to the iterative DFS implementation the only alteration required is to remove the next item from the beginning of the list structure instead of the stacks last.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'A', 'B', 'C', 'D', 'E', 'F'}"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def bfs(graph, start):\n",
    "    visited, queue = set(), [start]\n",
    "    while queue:\n",
    "        vertex = queue.pop(0)\n",
    "        if vertex not in visited:\n",
    "            visited.add(vertex)\n",
    "            queue.extend(graph[vertex] - visited)\n",
    "    return visited\n",
    "\n",
    "bfs(graph, 'A') # {'B', 'C', 'A', 'F', 'D', 'E'} ❌❌❌"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['A', 'C', 'B', 'F', 'D', 'E']"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ✅ Fixed?\n",
    "\n",
    "def bfs(graph, start):\n",
    "    visited, queue = [], [start] # ✅ Use list\n",
    "    while queue:\n",
    "        vertex = queue.pop(0)\n",
    "        if vertex not in visited:\n",
    "            visited.append(vertex)\n",
    "            queue.extend(graph[vertex] - set(visited)) # ✅ Convert list to set()\n",
    "    return visited\n",
    "\n",
    "bfs(graph, 'A') # ['A', 'C', 'B', 'F', 'D', 'E'] # ✅"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Paths\n",
    "\n",
    "This implementation can again be altered slightly to instead return all possible paths between two vertices, the first of which being one of the shortest such path.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['A', 'C', 'F'], ['A', 'B', 'E', 'F']]"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def bfs_paths(graph, start, goal):\n",
    "    queue = [(start, [start])]\n",
    "    while queue:\n",
    "        (vertex, path) = queue.pop(0)\n",
    "        for next in graph[vertex] - set(path):\n",
    "            if next == goal:\n",
    "                yield path + [next]\n",
    "            else:\n",
    "                queue.append((next, path + [next]))\n",
    "\n",
    "list(bfs_paths(graph, 'A', 'F')) # [['A', 'C', 'F'], ['A', 'B', 'E', 'F']]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Knowing that the shortest path will be returned first from the BFS path generator method we can create a useful method which simply returns the shortest path found or ‘None’ if no path exists. As we are using a generator this in theory should provide similar performance results as just breaking out and returning the first matching path in the BFS implementation.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['A', 'C', 'F']"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def shortest_path(graph, start, goal):\n",
    "    try:\n",
    "        return next(bfs_paths(graph, start, goal))\n",
    "    except StopIteration:\n",
    "        return None\n",
    "\n",
    "shortest_path(graph, 'A', 'F') # ['A', 'C', 'F']\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}

The set has the following signature for the __sub__ method:

• def __sub__(self, __value: AbstractSet[_T | None]) -> set[_T]:
  • This creates an intermediate set.

We can instead use an iterator directly from the visited list

• difference(*s: Iterable[Any]) -> set[str]
• stack.extend(graph[vertex].difference(visited))