ipython_nbs/essentials/greedy-algorithm-examples.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext watermark"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sebastian Raschka \n",
      "last updated: 2016-06-08 \n",
      "\n",
      "CPython 3.5.1\n",
      "IPython 4.2.0\n"
     ]
    }
   ],
   "source": [
    "%watermark -a 'Sebastian Raschka' -u -d -v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# More Greedy Algorithm Examples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For an introduction to greedy algorithm, see the related notebook, [Introduction to Greedy Algorithms](greedy-algorithm-intro.ipynb)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set Cover Problems"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Set cover problems are problems where we want to find the minimum number of subsets such that their set union contains all items in a target set. This target set is typically called the \"universe.\" To borrow an example from the excellent [Wikipedia page](https://en.wikipedia.org/wiki/Set_cover_problem) on set cover problems, let's assume we have the universe \n",
    "\n",
    "- $U=\\{1, 2, 3, 4, 5\\}$\n",
    "\n",
    "and are given the collection of sets \n",
    "\n",
    "- $C=\\{\\{1, 2, 3\\}, \\{2, 4\\}, \\{3, 4\\}, \\{4, 5\\}\\}$\n",
    "\n",
    "The task is to find the minimum number of sets in $C$ so that their union equals $U$.\n",
    "\n",
    "Note that set cover problems are NP-complete, thus no computationally efficient solution exists. However, we can use greedy algorithms to approximate the solution; this solution may or may not be globally optimal.\n",
    "\n",
    "The greedy strategy we are going to employ is very simple and works as follows:\n",
    "\n",
    "- While not all elements in U are covered:\n",
    "  - For all uncovered sets in C:\n",
    "  - Pick the set that covers most of the elements in U"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['set_1', 'set_2', 'set_4']\n"
     ]
    }
   ],
   "source": [
    "collection = {'set_1': {1, 2, 3},\n",
    "              'set_2': {2, 4}, \n",
    "              'set_3': {3, 4}, \n",
    "              'set_4': {4, 5}}\n",
    "sets_used = []\n",
    "elements_not_covered = {1, 2, 3, 4, 5}\n",
    "\n",
    "\n",
    "while elements_not_covered:\n",
    "    elements_covered = set()\n",
    "    for set_ in collection.keys():\n",
    "        \n",
    "        if set_ in sets_used:\n",
    "            continue\n",
    "        \n",
    "        current_set = collection[set_]\n",
    "        would_cover = elements_covered.union(current_set)\n",
    "        if len(would_cover) > len(elements_covered):\n",
    "            elements_covered = would_cover\n",
    "            sets_used.append(set_)\n",
    "            elements_not_covered -= elements_covered\n",
    "            \n",
    "            if not elements_not_covered:\n",
    "                break\n",
    "    \n",
    "print(sets_used)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As a result, we can see that 3 sets are required to cover the universe U. In this case, the greedy algorithm has not found the globally optimal solution, which would be `'set_1'` and `'set_4'`. Note that this is just a trivial example, and greedy algorithms can be very useful approximators for solutions that are computationally infeasible.\n",
    "\n",
    "For instance, an exhaustive solution to this problem that would guaranteed to find the global optimum (remember that set cover problems are NP-complete) would involve iterating over a power set, which has $2^n$ elements, where $n$ is the number of sets in the collection. For example, a collection of 30 sets would already require comparing the solutions of $2^{30}=1,073,741,824$ million possible combinations!\n",
    "\n",
    "(Note that the greedy approach may have found the globally optimal solution in this simple example if it had iterated over the dictionary in a different order -- for example, if we had swapped the positions of {2, 4} and {4, 5})"
   ]
  }
 ],
 "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.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}