Breadth First Search.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Breadth First Search\n",
    "\n",
    "In this notebook / blog post we will explore breadth first search, which is an algorithm for searching a given graph for the lowest cost path to a goal state $G$.\n",
    "\n",
    "The _cost_ is intentionally abstract as it can be defined as whatever you'd like it to be, whether it be the least amount of vertices traversed to get to $G$ or whether it be the lowest sum of the weights of edges between a given state and the goal state, $G$.\n",
    "\n",
    "Some quick notational and fundamental review of the definition of a graph is below :\n",
    "\n",
    "* Vertex\n",
    "    * End state, also called a node, of a given path through a graph $G$\n",
    "    * Can also house additional information known as a _payload_\n",
    "\n",
    "* Edge\n",
    "    * Also called an arc, the element that connects two vertices within a graph\n",
    "    * Can be either one way or two way; one way = **directed graph** or **digraph**\n",
    "    \n",
    "* Weight\n",
    "    * A value assigned to an edge to denote \"cost\" of traversing that edge between two vertices\n",
    "\n",
    "With these definitions we can formally define as a graph, $G$ where $G = (V,E)$.\n",
    "\n",
    "$V$ is a set of vertices and $E$ is a set of edges, respectively.\n",
    "\n",
    "Each edge is a tuple $(v,w)$ where $w,v \\in V$, adding $w$ as a third component to represent the weight of that vertex.\n",
    "\n",
    "* Path\n",
    "    * A sequence of edges that connect two vertices.\n",
    "    * Formally defined as $\\{w_{1},w_{2},...,w_{n}\\}$ such that $(w_{i},w_{i+1}) \\in E \\ \\ \\ \\forall 1 \\le i \\le n-1$\n",
    "    \n",
    "There are great libraries that provide Graph ADT's, but in this example we'll implement a Graph class ourselves. It will be useful in understanding a graph and how we can use it.\n",
    "\n",
    "We'll define two classes to support this effort, a `Vertex` class, which will represent a given vertex being added to the graph, and a `Graph` class which holds the master list of vertices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Vertex:\n",
    "    def __init__(self, key):\n",
    "        # unique ID for vertex\n",
    "        self.id = key\n",
    "        # dict of connected nodes\n",
    "        self.connected_to = {}\n",
    "    \n",
    "    def add_neighbor(self, neighbor, weight=0):\n",
    "        # Add an entry to the connected_to dict with a given\n",
    "        # weight \n",
    "        self.connected_to[neighbor] = weight\n",
    "        \n",
    "    def __str__(self):\n",
    "        # override __str__ for printing\n",
    "        return(str(self.id) + ' connected to: ' + str([x.id for x in self.connected_to]))\n",
    "    \n",
    "    def get_connections(self):\n",
    "        # return keys from connected_to dict\n",
    "        return self.connected_to.keys()\n",
    "    \n",
    "    def get_id(self):\n",
    "        # return vertex id's\n",
    "        return self.id\n",
    "    \n",
    "    def get_weight(self):\n",
    "        # return weights of edges connected to vertex\n",
    "        return self.connected_to[neighbor]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Graph:\n",
    "    def __init__(self):\n",
    "        # dictionary of vertices\n",
    "        self.vertices_list = {}\n",
    "        # vertex count\n",
    "        self.num_vertices = 0\n",
    "        \n",
    "    def add_vertex(self, key):\n",
    "        # increment counter when adding vertex\n",
    "        self.num_vertices = self.num_vertices + 1\n",
    "        new_vertex = Vertex(key)\n",
    "        self.vertices_list[key] = new_vertex\n",
    "        return new_vertex\n",
    "    \n",
    "    def get_vertex(self, n):\n",
    "        # check if vertex exists, return if True\n",
    "        if n in self.vertices_list:\n",
    "            return self.vertices_list[n]\n",
    "        else:\n",
    "            return None\n",
    "        \n",
    "    def __contains__(self, n):\n",
    "        # override __contains__ to list all vertices in Graph object\n",
    "        return n in self.vertices_list\n",
    "    \n",
    "    def add_edge(self, s, f, cost=0):\n",
    "        # add edge to graph; s = start node; e = end node\n",
    "        if s not in self.vertices_list:\n",
    "            nv = self.add_vertex(s)\n",
    "        if f not in self.vertices_list:\n",
    "            nv = self.add_vertex(f)\n",
    "        self.vertices_list[s].add_neighbor(self.vertices_list[f], cost)\n",
    "        \n",
    "    def get_vertices(self):\n",
    "        # return keys of vertices in Graph\n",
    "        return self.vertices_list.keys()\n",
    "    \n",
    "    def __iter__(self):\n",
    "        # override __iter__ to return iterable of vertices\n",
    "        return iter(self.vertices_list.values())\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "node_names = [\"A\", \"B\", \"C\",\n",
    "              \"D\", \"E\", \"F\",\n",
    "              \"G\"]\n",
    "# Instantiate graph object and add vertices\n",
    "g = Graph()\n",
    "for i in node_names:\n",
    "    g.add_vertex(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(A, B)\n",
      "(C, E)\n",
      "(B, E)\n",
      "(B, C)\n",
      "(E, F)\n",
      "(E, D)\n",
      "(D, B)\n"
     ]
    }
   ],
   "source": [
    "# add a bunch of edges between vertices\n",
    "g.add_edge('A','B')\n",
    "g.add_edge('B','C')\n",
    "g.add_edge('C','E')\n",
    "g.add_edge('E','D')\n",
    "g.add_edge('D','B')\n",
    "g.add_edge('E','F')\n",
    "g.add_edge('B','E')\n",
    "for v in g:\n",
    "    for w in v.get_connections():\n",
    "        print(\"(%s, %s)\" % (v.get_id(), w.get_id()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A connected to: ['B']\n",
      "B connected to: ['E', 'C']\n",
      "C connected to: ['E']\n",
      "D connected to: ['B']\n",
      "E connected to: ['F', 'D']\n",
      "F connected to: []\n",
      "G connected to: []\n"
     ]
    }
   ],
   "source": [
    "# list our vertices\n",
    "for i in node_names:\n",
    "    print(g.get_vertex(i))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from collections import deque\n",
    "\n",
    "def breadth_first_search(starting_node, goal_node):\n",
    "    visited_nodes = set()\n",
    "    queue = deque([starting_node])\n",
    "    \n",
    "    while len(queue) > 0:\n",
    "        node = queue.pop()\n",
    "        if node in visited_nodes:\n",
    "            continue\n",
    "        \n",
    "        visited_nodes.add(node)\n",
    "        if node.get_id == goal_node.get_id:\n",
    "            return True\n",
    "        \n",
    "        for n in node.connected_to:\n",
    "            if n not in visited_nodes:\n",
    "                queue.appendleft(n)\n",
    "    return False        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the `breadth_first_search` implementation that we've written, above, we can then ask the graph is there exists a path between multiple nodes. Our function will return a `True` or a `False` accordingly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "breadth_first_search(g.get_vertex('A'), g.get_vertex('G'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Past creating our own Vertex and Graph objects that we can use to assemble our own graphs, we can use libraries like NetworkX to create graphs and implement algorithms, like breadth first search, over them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/lib/pymodules/python2.7/matplotlib/collections.py:608: FutureWarning: elementwise comparison failed; returning scalar instead, but in the future will perform elementwise comparison\n",
      "  if self._edgecolors_original != 'face':\n",
      "/usr/lib/pymodules/python2.7/matplotlib/collections.py:548: FutureWarning: elementwise comparison failed; returning scalar instead, but in the future will perform elementwise comparison\n",
      "  if self._edgecolors == 'face':\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEACAYAAAC08h1NAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nrkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7ff39f5150d0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import networkx as nx\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "%matplotlib inline\n",
    "\n",
    "edges = [('A','B'),('B','C'),('C','E'),\n",
    "         ('E','D'),('D','B'),('E','F'),\n",
    "         ('B','E')]\n",
    "\n",
    "networkx_graph = nx.Graph()\n",
    "\n",
    "for node in node_names:\n",
    "    networkx_graph.add_node(node)\n",
    "\n",
    "networkx_graph.add_edges_from(edges)\n",
    "\n",
    "nx.draw_networkx(networkx_graph)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But the library also has the added ability to generate random graphs for us. In this case, the `dense_gnm_random_graph()` will generate a random graph of $G_{n,m}$ where $n$ is the node count and $m$ are the number of edges randomly distributed throughout the graph."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEACAYAAAC08h1NAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nEEIIIYQQQgjhPP4f0mN1Ecv8S/cAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7ff39d1a9910>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "networkx_graph_1 = nx.dense_gnm_random_graph(10,10)\n",
    "\n",
    "nx.draw_networkx(networkx_graph_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The networkx library tends to return iterators for each object within the graph context, such as the graph iteself, or the nodes within a graph or the neighbors of a particular node within the graph. This is useful because traversal algorithms such as breadth first search tend to operator in an iterative manner.\n",
    "\n",
    "`nodes` returns an iterable for the nodes in a graph\n",
    "\n",
    "`all_neighbors` returns an interable for all neighbors of a passed in graph and specific node"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Node 0 has neighbors : [3]\n",
      "Node 1 has neighbors : []\n",
      "Node 2 has neighbors : [4, 6]\n",
      "Node 3 has neighbors : [0, 9, 5]\n",
      "Node 4 has neighbors : [9, 2]\n",
      "Node 5 has neighbors : [3]\n",
      "Node 6 has neighbors : [8, 2]\n",
      "Node 7 has neighbors : [8, 9]\n",
      "Node 8 has neighbors : [9, 6, 7]\n",
      "Node 9 has neighbors : [8, 3, 4, 7]\n"
     ]
    }
   ],
   "source": [
    "# quick hack to traverse the iterables returned\n",
    "for node in nx.nodes(networkx_graph_1):\n",
    "    neighbors = []\n",
    "    for neighbor in nx.all_neighbors(networkx_graph_1, node):\n",
    "        neighbors.append(neighbor)\n",
    "    print(\"Node %s has neighbors : %s\" % (node, neighbors))   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or just because, here's a list comprehension that can do the same thing, that actually shows off a bit of Python's nested list comprehension functionality. It is possible to also push the `print` function into the list comprehension below, but it only works in Python 3+ and but is not considered pythonic -- so I'm only leaving it to return the nested arrays that a list comprehension normally would."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[3],\n",
       " [],\n",
       " [4, 6],\n",
       " [0, 9, 5],\n",
       " [9, 2],\n",
       " [3],\n",
       " [8, 2],\n",
       " [8, 9],\n",
       " [9, 6, 7],\n",
       " [8, 3, 4, 7]]"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[[neighbor for neighbor in nx.all_neighbors(networkx_graph_1, node)] for node in nx.nodes(networkx_graph_1)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The networkx library also includes many, many algorithm implementations already so we can utilize their built-in `breadth_first_search` algorithm, as we see below. We're able to print a traversal of the graph starting at `node 0` and print the entire path taken through the graph."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(0, 3), (3, 9), (3, 5), (9, 8), (9, 4), (9, 7), (8, 6), (4, 2)]\n"
     ]
    }
   ],
   "source": [
    "print(list(nx.bfs_edges(networkx_graph_1, 0)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Much like we see above, the networkx library also has a built-in depth first search algorithm that will traverse the graph and return an unordered list of tuples of edges that are traversed. I will save a depth first search implementation over our custom Graph object for future posts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(0, 3), (3, 9), (9, 8), (8, 6), (6, 2), (2, 4), (8, 7), (3, 5)]\n"
     ]
    }
   ],
   "source": [
    "print(list(nx.dfs_edges(networkx_graph_1, 0)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### References \n",
    "\n",
    "[Problem Solving with Algorithms and Data Structures](https://interactivepython.org/courselib/static/pythonds/index.html)\n",
    "\n",
    "[NetworkX Documentation](http://networkx.readthedocs.io/en/networkx-1.11/index.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}