C4W1_29BELLMAN_FORD_ALGORITHM_30ALL_PAIRS_SHORTEST_PATHS.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# XXIX. THE BELLMAN-FORD ALGORITHM \n",
    "The Bellman-Ford algorithm solves the single-source shortest-path problem. While slower than Dijkstra's algorithm, it accommodates negative edge lengths and is also better suited for distributed implementations. \n",
    "\n",
    "Ideally, we'd like to compute the shortest path distance from s to all other destinations v, where as usual, the length of the path is just the sum of the edge costs.  This goal is problematic for input graphs that have a negative cycle. If you allow cycled paths to contain cycles then this isn't even defined. The, in some sense, shortest path length is minus infinity. And if you don't allow cycles, then it's computationally intractable and would be a hard problem. So if you fail to compute shortest paths, then, at least, tell us an excuse. Output a \"negative cycle in the input graph\" as the reason for your failure to compute shortest path distances.\n",
    "\n",
    "![Bellman-Ford Algorithm](images/12_Bellman_Ford_Algorithm.png)\n",
    "\n",
    "\n",
    "### Optimal Substructure\n",
    "\n",
    "So in the Bellman-Ford algorithm, we're going to have one sub-problem for each possible destination, and each possible restriction on the number of edges in a path. So, for example, suppose we're looking at s and we're looking at destination t. And we think about paths that only have two edges or less. Well, in that case, the shortest path length, subject to that constraint from s to t in the below graph, has the length of four. The bottom path, which has three edges, is not an option, we're only permitting two edges or less in this current sub-problem. Now, if we bump up the edge budget to three, then the corresponding shortest path distance drops from four, to three. Because all of a sudden, we can make use of this three-hop path on the bottom. And again, the point here is that it gives us an unambiguous notion of sub-problem size. The more edges you're allowed to use in your paths, from a source to a given destination, the bigger that sub-problem.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x10b8f8b90>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import networkx as nx\n",
    "\n",
    "g = nx.Graph()\n",
    "g.add_node('s', pos = (0, 5))\n",
    "g.add_node('a', pos = (7.5, 10))\n",
    "g.add_node('g', pos = (5, 0))\n",
    "g.add_node('h', pos = (10, 0))\n",
    "g.add_node('t', pos = (15, 5))\n",
    "g.add_edge('s', 'a', weight = 2)\n",
    "g.add_edge('a', 't', weight = 2)\n",
    "g.add_edge('s', 'g', weight = 1)\n",
    "g.add_edge('g', 'h', weight = 1)\n",
    "g.add_edge('h', 't', weight = 1)\n",
    "pos = nx.get_node_attributes(g, 'pos')\n",
    "weights = nx.get_edge_attributes(g, 'weight')\n",
    "nx.draw_networkx_edge_labels(g, pos, edge_labels = weights)\n",
    "nx.draw(g, pos, with_labels = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The optimal solution to a sub-problem has to be one of a small number of candidates that are composed in simple ways from optimal solutions to smaller sub-problems. So how do we index a given sub-problem? Well, there's going to be a destination v, that we care about. And, there's going to be a budget on how many edges you're allowed to use in a path from s to v. And we're going to use i to denote that budget.\n",
    "So for every possible destination v, and so for every possible edge budget, there's going to be a positive integer, 1 or bigger.\n",
    "Suppose that p is an optimal solution then. Meaning, amongst all paths that start at s, that end at v, and that contain, at most, i edges. Amongst all of those paths, p has the minimum sum of edge cost, the minimum length.\n",
    "\n",
    "    G = (V, E)\n",
    "    for every v ∈ V, i ∈ {1, 2, 3, ...} \n",
    "        P = shortest s-v path with at most i edges\n",
    "        \n",
    "Case I:    <br>\n",
    "We're going to have our usual trivial case 1, which is that if this path P doesn't bother to use up its full edge budget, that is if it has (i-1) edges or less, well then, naturally, P better be the shortest s-v path that has at most (i-1) edges. <br>\n",
    "Case II:<br>\n",
    "So the non-trivial case is when the shortest path with the most i edges from s to v actually uses its full budget, uses all i of its edges. Case two may seem like only one other candidate, but actually case two comprises a number of them, one for each choice of that final hop w, v. Specifically for a given choice of w, that contributes a candidate optimal solution that's the shortest path from s, to that choice of w that uses the most i minus 1 edges, plus that edge wv tacked on.\n",
    "\n",
    "### The Basic Bellman-Ford Algorithm\n",
    "![Bellman-Ford Algorithm](images/12_bellmanfordalgo.png)\n",
    "\n",
    "For each choice of I and V, of course, we just write down in code the formula that we stated in the recurrence. So, case one furnishes one possible candidate. It's always an option to just inheret, the shortest path from S to V that you computed using only, $i-1$ edges.Alternatively from case two, there's also one candidate furnished for each twist of the final hop, so for each edge, that ends at $v$, for each choice $(w, v)$, there's an option of taking a shortest path from $s$ to $w$, that uses only, $i-1$ edges, and tacking on that final edge, $(w, v)$. And as we've discussed, if it just so happens that the input graph $G$ has no negative cycles, then this algorithm will indeed terminate with a correct shortest path from S to all of the destinations. Those answers will be lying in wait for you, in the biggest subproblems, the $A[n-1][v]$'s. \n",
    "\n",
    "\n",
    "\n",
    "### Stopping Early\n",
    "So in general, suppose that some iteration, earlier than the last one, so say with a current index value of j, it just so happens that nothing changes. That every destination v, you just reuse the optimal solution that you recomputed in the previous iteration of the outer 4 loop. Well then if you think about it, what's going to happen in the next iteration? You're going to do exactly the same set of computations, with exactly the same set of inputs, so you're going to get exactly the same set of results. That is, it will be true again in the next iteration that you will just inherit the optimal solutions from the previous one. And that will keep happening over and over again until the rest of time.\n",
    "\n",
    "So in particular, by the time you get to the n minus 1 iteration of the outer 4 loop, you will have exactly the same set of solution values as you do right now. We've already proven that the results at the end of iteration n minus 1 are correct. Those are the real shortest path distances. If you already have them in your grubby little hands now, well you may as well abort the algorithm and return those as the final correct shortest path distances.\n",
    "\n",
    "\n",
    "### Detecting Negative Cycles\n",
    "The presence of negative cost cycles in an input graph is characterized by the behavior of Bellman Ford in an extra iteration. That's why it's easy to extend the basic algorithm. To check negative cycles without affecting the running time.  <br>\n",
    "G the input graph has no negative cycle, if and only if we don't get any new information from this extra batch of sub-problems. That is if and only if, $A[n][v]$ is exactly the same thing as $A[n-1][v]$ for every possible destination V. Equivalently the input graph does have a negative cost cycle if and only if there exists some sub-problem. There exists some destination $v$, where we see an improvement at $v$ by running the Bellman Ford out for this extra iteration.\n",
    "\n",
    "\n",
    "\n",
    "### Running Time\n",
    "<table>\n",
    "    <caption>&nbsp;&nbsp;&nbsp;&nbsp; Bellman-Ford Algorithm</caption>\n",
    "    <tr> <td>$\\textbf{Operation}$ </td> <td>\t$\\textbf{Running Time}$ <td> </tr>\n",
    "    <tr> <td> The Basic Bellman-Ford Algorithm </td>\t<td>$O(m n)$ <td> </tr>\n",
    "    <tr> <td> Bellman-Ford Algorithm with Detecting Negative Cycles </td>\t<td>$O(m n)$ <td> </tr>\n",
    "</table>\n",
    "\n",
    "\n",
    "### A Space Optimization\n",
    "\n",
    "The space required by the basic Bellman-Ford algorithm is quadratic in the number of vertices. It is theta of $n^2$.\n",
    "as soon as we finished one batch of sub-problems for some value of $i$, we've computed $A[i][v]$ for all $v$, we can throw out the results of all of the previous rounds of sub-problems. $A[i-2]$, $A[i-3]$, and so on. All we need is the freshest batch $A[i-1][v]$, the most recent iteration, to correctly proceed. If we do that, the only sub problems we're keeping track of are the ones that we're filling in, in the current round $i$ and we're remember the solutions from the previous round $i - 1$, that means at any given moment in time we're only keeping track of $O(n)$ different sub problems. And this linear space bound is even more impressive than it might appear at first, and that's because if you think about the responsibility of our algorithm in this problem, we have to output a linear number of things, right? We're not just outputting one number. We're outputting n numbers, shortest path distance from s to every possible destination. So the space is really constant per statistic that we have to compute. \n",
    "\n",
    "##### Reconstruction Algorithm:\n",
    "\n",
    "We have this 2-D array capital B, it's indexed by the edge budget $i$ and it's indexed by the destination $v$ and we're supposed to fill in  $B[i][v]$ with a final hop on a shortest path from s to v that uses at most $i$ edges and if no such paths exist then it's just null. For the base case that's when $i$ equals zero and here everybody's predecessor pointer is null. <br>\n",
    "So the way we're going to fill in the entry $B[i][v]$ is going to depend on which of the candidates won in the competition to be the shortest path for $A[i][v]$. In essence this predecessor pointer $B[i][v]$ is just caching the results of the competition we ran to find the shortest path for $A[i][v]$.<br>\n",
    "Case one is when you inherit the solution from the last round $A[i-1][v]$. In addition each possible choice for a last hop $(w, v)$ furnishes another candidate for the optimal solution of this round in which your going to pay, you're going to pay the optimal solution to the sub problem $[i - 1][w]$ plus the length of the edge $(w, v)$. <br>\n",
    "Now notice that, just like the formula that we used to populate the capital $A$ array. The original array. To compute these $B[i][v]$s, all we need to know is information from the last round. Information from the round $i - 1$. So just like with the $A$ array, we can throw out all of the predecessor pointers that date back before yesterday. Before the previous round. Therefore, we again, need only constant space per destination v. To maintain both the shortest path distance from $s$ to $v$ with the most $i$-hops. And the predecessor pointer. We can also compute the predecessorpointers in that same space which allows the reconstruction of shortest paths.  <br>\n",
    "\n",
    "\n",
    "<table>\n",
    "    <caption>&nbsp;&nbsp;&nbsp;&nbsp; Bellman-Ford Algorithm </caption>\n",
    "    <tr> <td>$\\textbf{Operation}$ </td> <td>\t&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;$\\textbf{      Space  }$ <td> </tr>\n",
    "    <tr> <td> The Basic Bellman-Ford Algorithm </td>\t<td>$O(n^2)$<td> </tr>\n",
    "    <tr> <td> Bellman-Ford Algorithm with Space Optimization</td>\t<td>$O(n)$ <td> </tr>\n",
    "    <tr> <td> Bellman-Ford Algorithm with Space Optimization and Reconstruction Algorithm</td>\t<td>$O(n)$ <td> </tr>\n",
    "</table>\n",
    "\n",
    "\n",
    "##### To reconstruct a negative cycle\n",
    "It turns out you can solve the reconstruction problem for negative cost cycles as well, using the Bellman-Ford algorithm and predecessor pointers in exactly the way we've been maintaining them here. I'm not going to talk through all of the details of the solution. I'll leave it to you as a somewhat nontrivial exercise to think through how this really works, but the gist is as follows, so you run the Bellman-Ford algorithm, you maintain the predecessor pointers as on this slide, and if the input graph does have a negative cost cycle, then at some iteration, you will see a cycle amongst the predecessor pointers. Furthermore, that cycle of predecessor pointers must be a negative cost cycle of the original input graph. This means that detecting a negative cost cycle if one exists reduces to checking for a cycle in the predecessor pointers which of course you can solve using depth for a search at every iteration.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A : \n",
      "[[inf 0 inf inf inf]\n",
      " [4 0 inf inf 2]\n",
      " [3 0 8 4 2]\n",
      " [3 0 6 4 2]]\n",
      "Shortest path (s, x): 3\n",
      "Shortest path (s, s): 0\n",
      "Shortest path (s, t): 6\n",
      "Shortest path (s, w): 4\n",
      "Shortest path (s, v): 2\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import networkx as nx\n",
    "\n",
    "def Bellman_Ford_Algorithm_tabular(graph, A, nodes, i_start_vert):\n",
    "    row, col = A.shape\n",
    "    for i in range(1, row):\n",
    "        for v in range(col):\n",
    "            if v == i_start_vert:\n",
    "                A[i][v] = 0\n",
    "                continue\n",
    "            case_sum_subproblems = []\n",
    "            case_1 = A[i-1][v]\n",
    "            for pre in DG.predecessors(nodes[v]):\n",
    "                w = nodes.index(pre)\n",
    "                case_sum_subproblems.append(A[i-1][w] + graph.edges[nodes[w], nodes[v]]['weight'])\n",
    "            if len(case_sum_subproblems) != 0:\n",
    "                case_2 = min(case_sum_subproblems)\n",
    "                A[i][v] = min(case_1, case_2)\n",
    "    \n",
    "    \n",
    "def Bellman_Ford_Algorithm_basic(graph, start_vert): \n",
    "    nodes = list(graph.nodes)\n",
    "    A = np.full((len(nodes)-1, len(nodes)), None) \n",
    "    i_start_vert = nodes.index(start_vert)\n",
    "    A[0] = float('inf')\n",
    "    A[0][i_start_vert] = 0\n",
    "    Bellman_Ford_Algorithm_tabular(graph, A, nodes, i_start_vert)\n",
    "    print(\"A : \\n{}\".format(A))\n",
    "    shortest_paths = A[-1]\n",
    "    for idx in range(len(shortest_paths)):\n",
    "        print(\"Shortest path ({}, {}): {}\".format(start_vert, nodes[idx], shortest_paths[idx]))\n",
    "    \n",
    "\n",
    "DG = nx.DiGraph()\n",
    "for i,j in zip(['s', 'v', 'w', 'x', 't'],[(0, 5), (5, 10), (10, 10), (7.5, 0), (15, 5)]):\n",
    "    DG.add_node(i, pos=j)\n",
    "DG.nodes.data()\n",
    "DG.add_weighted_edges_from([('s', 'v', 2), ('v', 'w', 2), ('w', 't', 2), ('s', 'x', 4), ('v', 'x', 1), ('x', 't', 4)])\n",
    "pos = nx.get_node_attributes(DG, 'pos')\n",
    "weights = nx.get_edge_attributes(DG, 'weight')\n",
    "nx.draw_networkx_edge_labels(DG, pos, edge_labels = weights)\n",
    "nx.draw_networkx_labels(DG,pos=pos)\n",
    "nx.draw(DG, pos, with_labels = True)\n",
    "start_vert = 's'\n",
    "Bellman_Ford_Algorithm_basic(DG, start_vert)    \n",
    "    \n",
    "   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bellman Ford Algorithm  using Dynamic Programming with:\n",
    "\n",
    "    ► Negative edge cost \n",
    "    ► Space Optimization\n",
    "    ► Stopping Early\n",
    "    ► Negative Cycle Detection\n",
    "    ► Reconstruction Algorithm in case where negative cycle is not detected"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A : \n",
      "[[0 0 -6 -3 -8]\n",
      " [0 0 -6 -3 -8]]\n",
      "Bellman Ford Algorithm - Shortest path distance:\n",
      "(s, s): 0\n",
      "(s, v): 0\n",
      "(s, w): -6\n",
      "(s, x): -3\n",
      "(s, t): -8\n",
      "Bellman Ford Algorithm Reconstructing the shortest paths: \n",
      "(s, s) : ['s']\n",
      "(s, v) : ['s', 'v']\n",
      "(s, w) : ['s', 'v', 'x', 't', 'w']\n",
      "(s, x) : ['s', 'v', 'x']\n",
      "(s, t) : ['s', 'v', 'x', 't']\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[[0, 0, -6, -3, -8], ['s', 'v', 'w', 'x', 't']]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import networkx as nx\n",
    "\n",
    "def Bellman_Ford_Algorithm_dynamic(graph, A, B, nodes, i_start_vert):\n",
    "    row, col = A.shape\n",
    "    negative_cycle = False\n",
    "    early_stopped = False\n",
    "    for i in range(1, col+1):\n",
    "        if all(A[0] == A[1]):  # stopping early\n",
    "            early_stopped = True\n",
    "            break\n",
    "        A[0] = A[1]\n",
    "        B[0] = B[1]\n",
    "        for v in range(col):\n",
    "            case_sum_subproblems = []\n",
    "            case_1 = A[0][v]\n",
    "            case_1_b = B[0][v]\n",
    "            for pre in graph.predecessors(nodes[v]):\n",
    "                w = nodes.index(pre)\n",
    "                #print(\"i: {}, iw: {}, w: {}, v: {}, sw: {}, wv: {} \".format(i, w,nodes[w], nodes[v], A[0][w] , graph.edges[nodes[w], nodes[v]]['weight']))\n",
    "                case_sum_subproblems.append([A[0][w] + graph.edges[nodes[w], nodes[v]]['weight'], w])\n",
    "                #print(case_sum_subproblems)\n",
    "            if len(case_sum_subproblems) != 0:\n",
    "                case_2 = min(case_sum_subproblems)\n",
    "                case_2_b = case_2[1]\n",
    "                #print(\"case_1: {} case_2: {}\".format(case_1, case_2))\n",
    "                if case_1 <= case_2[0]:\n",
    "                    A[1][v] = case_1\n",
    "                    B[1][v] = case_1_b\n",
    "                else:\n",
    "                    A[1][v] = case_2[0]\n",
    "                    B[1][v] = case_2_b\n",
    "                #print(A)\n",
    "                #print(B)\n",
    "    if any(A[0] != A[1]) and (early_stopped == False) :  # Negative Cycle Detection\n",
    "        negative_cycle = True\n",
    "    return negative_cycle\n",
    "    \n",
    "    \n",
    "def reconstruction_algorithm(graph, A, B, nodes, i_start_vert):\n",
    "    print(\"Bellman Ford Algorithm Reconstructing the shortest paths: \")\n",
    "    for v in range(len(nodes)):\n",
    "        path_node = v\n",
    "        path = []\n",
    "        while path_node != i_start_vert:\n",
    "            path.append(nodes[path_node])\n",
    "            path_node = B[1][path_node]\n",
    "        path.append(nodes[i_start_vert])\n",
    "        print(\"({}, {}) : {}\".format(nodes[i_start_vert], nodes[v], path[::-1]))\n",
    " \n",
    "    \n",
    "def Bellman_Ford_Algorithm_optimize(graph, start_vert): \n",
    "    nodes = list(graph.nodes)\n",
    "    #A = np.full((len(nodes)-1, len(nodes)), None) \n",
    "    A = np.full((2, len(nodes)), None)   # space optimization\n",
    "    B = np.full((2, len(nodes)), None)   # Reconstruction Algorithm\n",
    "    i_start_vert = nodes.index(start_vert)\n",
    "    A[1] = float('inf')\n",
    "    A[1][i_start_vert] = 0\n",
    "    B[1][i_start_vert] = i_start_vert\n",
    "    negative_cycle = Bellman_Ford_Algorithm_dynamic(graph, A, B, nodes, i_start_vert)\n",
    "    if negative_cycle == False:\n",
    "        print(\"A : \\n{}\".format(A))\n",
    "        shortest_paths = A[-1]\n",
    "        print(\"Bellman Ford Algorithm - Shortest path distance:\")\n",
    "        for idx in range(len(shortest_paths)):\n",
    "            print(\"({}, {}): {}\".format(start_vert, nodes[idx], shortest_paths[idx]))\n",
    "        reconstruction_algorithm(graph, A, B, nodes, i_start_vert)\n",
    "        return [list(shortest_paths), nodes]\n",
    "    else:\n",
    "        print(\"Error: Negative Cycle detected in graph. Bellman-Ford Algorithm does not allow negative cycle.\")\n",
    "        return False\n",
    "      \n",
    "    \n",
    " \n",
    "\n",
    "## Negative edge cost + Reconstruction Algorithm\n",
    "DG = nx.DiGraph()\n",
    "for i,j in zip(['s', 'v', 'w', 'x', 't'],[(0, 5), (5, 10), (10, 10), (7.5, 0), (15, 5)]):\n",
    "    DG.add_node(i, pos=j)\n",
    "DG.nodes.data()\n",
    "DG.add_weighted_edges_from([('s', 'v', 0), ('v', 'w', 2), ('w', 't', 2), ('t', 'w', 2), ('s', 'x', 4), ('v', 'x', -3), ('x', 't', -5)])\n",
    "pos = nx.get_node_attributes(DG, 'pos')\n",
    "weights = nx.get_edge_attributes(DG, 'weight')\n",
    "nx.draw_networkx_edge_labels(DG, pos, edge_labels = weights)\n",
    "nx.draw_networkx_labels(DG,pos=pos)\n",
    "nx.draw(DG, pos, with_labels = True)\n",
    "start_vert = 's'\n",
    "Bellman_Ford_Algorithm_optimize(DG, start_vert)    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error: Negative Cycle detected in graph. Bellman-Ford Algorithm does not allow negative cycle.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x11946f490>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "## Negative edge cost + Reconstruction Algorithm\n",
    "DG = nx.DiGraph()\n",
    "for i,j in zip(['s', 'v', 'w', 'x', 't'],[(0, 5), (5, 10), (10, 10), (7.5, 0), (15, 5)]):\n",
    "    DG.add_node(i, pos=j)\n",
    "DG.nodes.data()\n",
    "DG.add_weighted_edges_from([('s', 'v', 0), ('v', 'w', 2), ('w', 't', 2), ('t', 'w', 2), ('s', 'x', -4), ('x', 's', -4), ('v', 'x', -3), ('x', 't', -5)])\n",
    "pos = nx.get_node_attributes(DG, 'pos')\n",
    "weights = nx.get_edge_attributes(DG, 'weight')\n",
    "nx.draw_networkx_edge_labels(DG, pos, edge_labels = weights)\n",
    "nx.draw_networkx_labels(DG,pos=pos)\n",
    "nx.draw(DG, pos, with_labels = True)\n",
    "start_vert = 's'\n",
    "Bellman_Ford_Algorithm_optimize(DG, start_vert)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A : \n",
      "[[3 0 6 4 2]\n",
      " [3 0 6 4 2]]\n",
      "Bellman Ford Algorithm - Shortest path distance:\n",
      "(s, x): 3\n",
      "(s, s): 0\n",
      "(s, t): 6\n",
      "(s, w): 4\n",
      "(s, v): 2\n",
      "Bellman Ford Algorithm Reconstructing the shortest paths: \n",
      "(s, x) : ['s', 'v', 'x']\n",
      "(s, s) : ['s']\n",
      "(s, t) : ['s', 'v', 'w', 't']\n",
      "(s, w) : ['s', 'v', 'w']\n",
      "(s, v) : ['s', 'v']\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[[3, 0, 6, 4, 2], ['x', 's', 't', 'w', 'v']]"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x10ea4aad0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "## Space Optimization \n",
    "DG = nx.DiGraph()\n",
    "for i,j in zip(['s', 'v', 'w', 'x', 't'],[(0, 5), (5, 10), (10, 10), (7.5, 0), (15, 5)]):\n",
    "    DG.add_node(i, pos=j)\n",
    "DG.nodes.data()\n",
    "DG.add_weighted_edges_from([('s', 'v', 2), ('v', 'w', 2), ('w', 't', 2), ('s', 'x', 4), ('v', 'x', 1), ('x', 't', 4)])\n",
    "pos = nx.get_node_attributes(DG, 'pos')\n",
    "weights = nx.get_edge_attributes(DG, 'weight')\n",
    "nx.draw_networkx_edge_labels(DG, pos, edge_labels = weights)\n",
    "nx.draw_networkx_labels(DG,pos=pos)\n",
    "nx.draw(DG, pos, with_labels = True)\n",
    "start_vert = 's'\n",
    "Bellman_Ford_Algorithm_optimize(DG, start_vert)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A : \n",
      "[[1 1 1 3 2 0 2]\n",
      " [1 1 1 3 2 0 2]]\n",
      "Bellman Ford Algorithm - Shortest path distance:\n",
      "(s, a): 1\n",
      "(s, d): 1\n",
      "(s, g): 1\n",
      "(s, i): 3\n",
      "(s, h): 2\n",
      "(s, s): 0\n",
      "(s, t): 2\n",
      "Bellman Ford Algorithm Reconstructing the shortest paths: \n",
      "(s, a) : ['s', 'a']\n",
      "(s, d) : ['s', 'd']\n",
      "(s, g) : ['s', 'g']\n",
      "(s, i) : ['s', 'g', 'h', 'i']\n",
      "(s, h) : ['s', 'g', 'h']\n",
      "(s, s) : ['s']\n",
      "(s, t) : ['s', 'a', 't']\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[[1, 1, 1, 3, 2, 0, 2], ['a', 'd', 'g', 'i', 'h', 's', 't']]"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x119aa8150>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "## Stopping Early\n",
    "DG = nx.DiGraph()\n",
    "for i,j in zip(['s', 'a', 'd', 'g', 'h', 'i', 't'],[(0, 5), (5, 10), (5, 5), (5, 0), (10, 0), (15, 0), (20, 5)]):\n",
    "    DG.add_node(i, pos=j)\n",
    "DG.nodes.data()\n",
    "DG.add_weighted_edges_from([('s', 'a', 1), ('s', 'd', 1), ('s', 'g', 1), ('a', 't', 1), ('d', 't', 100), ('g', 'h', 1), ('h', 'i', 1), ('i', 't', 100), ('i', 'a', 1), ('d', 'a', 1)])\n",
    "pos = nx.get_node_attributes(DG, 'pos')\n",
    "weights = nx.get_edge_attributes(DG, 'weight')\n",
    "nx.draw_networkx_edge_labels(DG, pos, edge_labels = weights)\n",
    "nx.draw_networkx_labels(DG,pos=pos)\n",
    "nx.draw(DG, pos, with_labels = True)\n",
    "start_vert = 's'\n",
    "Bellman_Ford_Algorithm_optimize(DG, start_vert)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error: Negative Cycle detected in graph. Bellman-Ford Algorithm does not allow negative cycle.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1193a8e10>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "## Negative Cycle Detected\n",
    "DG = nx.DiGraph()\n",
    "for i,j in zip(['s', 'v', 'w', 'x', 't'],[(0, 5), (5, 10), (10, 10), (7.5, 0), (15, 5)]):\n",
    "    DG.add_node(i, pos=j)\n",
    "DG.nodes.data()\n",
    "DG.add_weighted_edges_from([('s', 'v', 2), ('w', 'v', 2), ('t', 'w', -50), ('s', 'x', 4), ('v', 'x', 1), ('x', 't', 4)])\n",
    "pos = nx.get_node_attributes(DG, 'pos')\n",
    "weights = nx.get_edge_attributes(DG, 'weight')\n",
    "nx.draw_networkx_edge_labels(DG, pos, edge_labels = weights)\n",
    "nx.draw_networkx_labels(DG,pos=pos)\n",
    "nx.draw(DG, pos, with_labels = True)\n",
    "start_vert = 's'\n",
    "Bellman_Ford_Algorithm_optimize(DG, start_vert)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Internet Routing \n",
    "\n",
    "Now as you can imagine, there's a fairly long list of engineering challenges that have to be tackled to move from the basic Bellman-Ford algorithm to a routing protocol that you could conceivably use in practice. So what I'll do here is highlight some of the main issues and what's the high level solution to those issues and with those fixes to the basic Bellman-Ford algorithm, we'll actually have something that's surprisingly close to how modern day Internet protocols, protocols really work. <br>\n",
    "\n",
    "The first and simplest modification to the algorithm is motivated by the fact that routing in the internet is destination-driven. Given a piece of data floating around in the internet, you really don't care that much where it came, where it came from. All you have to do to accommodate destination driven routing is reverse all of the directions in the Bellman-Ford algorithm. So instead of having a source vertex, S, out of which you compute all shortest paths, you're going to have a destination vertex, T, into which you computeshortest paths from all possible origins. Each vertex, rather than storing a predecessor pointer, the final hop on a shortest path from S to that vertex, it's going to store the first hop on a shortest path to the destination, t. \n",
    "\n",
    "So, the second issue we need to address is a little more serious, but it's stillnot too bad. This issue is asynchrony. And what I mean is if you look back at our basic Bellman-Ford algorithm it was synchronous in the following sense. We were careful to structure the outeriteration of the four loop so that all of the sub problems corresponding to value i - 1 gets solved before any of the sub problems with index i. Now when you're talking about the internet and you have different routers, different computers running at different speeds. You have different physical connections with different bandwidth. There's no way you're going to keep people in sync. There's noway you can implement synchronized rounds at the Internet scale. But what's cool is that the Bellman-Ford algorithm is surprisingly robust, to the order in which you solve its subproblems. Really if you solve them in any kind of reasonable order, you're still going to be computing correct shortest paths at the end of the day. So to explain what I mean, let's change the Bellman-Ford algorithm to be push-based rather than pull-based. So the basic Bellman-Ford algorithm is pull based in the following sense. For each other iteration I, and each vertex V, in this iteration, the vertex V in effect asks its neighbors, for their most recent information. So, for there, sub-problem solution values, from the last iteration of the outer four loop. We're going to change it to be push based, which is rather than asking your neighbor for the latest information, whenever you have something new to say, whenever your sub-problem value changes you're just going to go ahead and tell all of your neighbors. You're going to push that information onto your neighbors whether they want it or not. \n",
    "\n",
    "So the original Bellman-Ford Algorithm is from the 1950s, and with the modifications we've discussed to this point, we're up to routing protocols that were deployed as late as the 1970s. So if you want to read more you can look at the RIP and RIP2 Internet routing protocols. And if you really want to be nerdy about it you can check out the request for comments related to these protocols. RFC number 1058.\n",
    " \n",
    "##### counting to infinity problem: \n",
    "So now, let's talk about the final and most serious problem, which is that stuff in the Internet, nodes, links, etc., is failing all the time. You know its true that we just argued that the asynchronous bellman ford shortest path rounding protocol is guaranteed to converge to correct shortest path. that was assuming that the network was static that no legs were coming up and down. So one particularly simple problem in a presence of failure is what's known as the counting to infinity problem. <br>\n",
    "So imagine we just have a super simple network verticies s, v, and t by directed arch from s to v and an arc from v to t everything has unit cost and we're doing it routing to the destination t. You might if you want a more realistic example, think about the arcs between S and V as standing in for longer paths that have multiple hops. In any case let's imagine that wesuccessfully computed shortest paths on this basic network so that distance form T to itself is zero, from V to T is one and from S to T is two. Now, again, the issue is that links are failing all the time on the internet. So, at some point, this link from V to T might go down. \n",
    "And in an effort to recover connectivity to t, it makes sense for v to ask it'sneighbors, do they have paths to t? And if so, how long are they? So in particular, v will pull s, and s will say, oh yeah, I have a path to t of distance only two. And v says, oh well that's great. I, currently my estimate to t is plus infinity. I can get to s with length one, s says it can get back to t with length two. So that gives me a path of length three to t. \n",
    "Now, of course the flaw in this reasoning is that s was depending on v to get to t and now all of a sudden because $(v,t)$ link broke, v circularly is going to use s in its mind to get all the way back to t. So this already illustrates the dangers of naively implementing the asynchronous Bellman Ford algorithm in the presence of link failures. \n",
    "![Bellman-Ford Algorithm](images/13_counting_to_infinity_link_failure.png)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "***\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# XXX. ALL-PAIRS SHORTEST PATHS  (APSP)\n",
    "In contrast to the single source shortest path problem, there is no distinguished source vertex. And the goal of ALL-PAIRS SHORTEST PATHS  is to compute for every pair of vertices u and v, the length of a shortest path starting at u and ending at v. <br>\n",
    "Should we be happy with this algorithm that simply runs a single source shortest path algorithm n times? Or do we expect to do better? Well, the answer's going to depend. It's going to depend on two factors. First of all, does the input graph have only non negative edge costs? Or does it more generally also have negative edge costs? The second thing we want to look at is whether the graph is sparse. Meaning m, the number of edges is relatively close to n. Or is it dense, meaning m is relatively close to n^2? \n",
    "<table>\n",
    "    <caption>&nbsp;&nbsp;&nbsp;&nbsp; Bellman-Ford Algorithm</caption>\n",
    "    <tr> <td>$\\textbf{Operation}$ </td>  <td>$\\textbf{Description}$ </td><td>\t$\\textbf{Running Time}$ </td><td>\t$\\textbf{Running Time (Dense and Sparse graphs)}$ </td> </tr>\n",
    "    <tr> <td> n * Dijkstra's </td><td> non-negative edge costs </td>\t<td>$O(n m logn)$ </td> <td>$O(n^2 logn)$ if m=$O(n)$ </td> </tr>\n",
    "    <tr> <td> n * Dijkstra's </td><td> </td><td> </td>\t<td>$O(n^3 logn)$ if m=$O(n^2)$ </td> </tr>\n",
    "    <tr> <td> n * Bellman-Ford </td><td> general edge costs </td>\t<td>$O(n^2 m)$ </td> <td>$O(n^3)$ if m=$O(n)$ </td> </tr>\n",
    "    <tr> <td> n * Bellman-Ford </td><td> </td><td> </td>\t<td>$O(n^4)$ if m=$O(n^2)$ </td> </tr>\n",
    "</table>\n",
    "\n",
    "\n",
    "\n",
    "# Floyd-Warshall algorithm\n",
    "We're going to develop, from scratch, a algorithm for the all pair shortest path problem. Rather than by relying on the aforementioned reduction to the single source version of the problem. <br>\n",
    "\n",
    "### Optimal Substructure\n",
    "It can be tricky to apply dynamic programming to graph problems because there isn't really an ordering in the input. You just get this bag of vertices and this bag of edges. And it's often unclear how to define bigger and smaller subproblems.\n",
    "\n",
    "So the really nice solution in the Bellman-Ford algorithm was to introduce this extra parameter I. I was a budget on the number of edges or roughly equivalently the number of vertices that you are allowed to use in a path. Between the origin and destination for a given subproblem. This naturally induces an ordering on subproblems, the bigger the edge budget, the bigger the subproblem. We're going to do something similar but even a little bit more stringent in the Floyd-Warshall solution. We're again going to restrict the number of vertices that can appear in the middle of the path between a given origin and destination and a subproblem. But more than just the number of the vertices we're allowed to use, we're going to restrict exactly which vertices, the identities of the vertices that the algorithms permitted to use to get from the given origin to the given destination.\n",
    "\n",
    "So to be a little bit more formal about it, let's just impose some arbitrary ordering on the vertices capital $V$, name the vertices one, two, three, all the way up to $n$. I don't care how. And I'm going to use the notation capital $V^{(k)}$  to denote the prefix of the first $k$ vertices, vertices one through $k$.\n",
    "\n",
    "All right, so this is actually going to be one of the simpler optimal substructural lemma that we've seen in a while. We're back to the glory days of only two cases. The first is trivial, if the shortest path from I to J using only vertices one through K as intermediaries doesn't even bother to use the vertex K, well then it better well be a shortest path from I to J that uses internal nodes only from one to K-1. Now it's in case two it's going to be apparent what a great idea ordering the vertices looking at prefixes. The vertices is when you're considering the all pairs version of the shortestpath problem. Suppose this path P from I to J does indeed use the vertex K in the middle. Well than we can think of the path P as comprising two sub paths. The first path P1 which starts at I and goes to the vertex K. And then a path P2 which starts at K and goes to the destination J. Now here's what's cool. So on this path P the internal nodes between I and J all lie in one through K.Moreover, this path P remembers cycle free so the vertex K appears exactly once, not more than once. So therefore if we split the path P into these two parts, P1 and P2, internal to P1, strictly in between I and K. There's only vertices between one and K-1. Similarly strictly between K and J and P2, there's only vertices between one through K-1. Thus both of these paths, P1 and P2 can be thought of as feasible solutions to smaller subproblems. Subproblems with an even tighter budget of K minus 1 on the internal nodes that are allowed and these aren't just feasible solutions for smaller subproblems, they're optimal solutions as well. \n",
    "\n",
    "### The Floyd-Warshall Algorithm\n",
    "\n",
    "\n",
    "![Floyd Warshall Algorithm](images/14_Floyd_WarshallAlgorithm.png)\n",
    "\n",
    "\n",
    "\n",
    "### Running Time\n",
    "<table>\n",
    "    <caption>&nbsp;&nbsp;&nbsp;&nbsp; Floyd Warshall Algorithm</caption>\n",
    "    <tr> <td>$\\textbf{Operation}$ </td> <td>\t$\\textbf{Running Time}$ <td> </tr>\n",
    "    <tr> <td> Floyd Warshall Algorithm </td>\t<td>$O(n^3)$ <td> </tr>\n",
    "</table>\n",
    "\n",
    "\n",
    "***\n",
    "\n",
    "\n",
    "# Johnson's Algorithm\n",
    "\n",
    "Johnson's algorithm remarkably shows that the same running time we get here for the non-negative edge limit case, $O(n n logn)$, we can get equally well for graphs that have general edge lengths.\n",
    "\n",
    "Specifically, Johnson's algorithm shows that the alt pair shortest path problem in graphs with general edge lengths reduces to one indication of the Bellman-Ford algorithm followed by an indication of Dijkstra's algorithm. As we know, the Bellman-Ford algorithm runs in $O(mn)$ time. Any indications to Dijkstra's Algorithm is going to be $O(n m logn)$. Putting it together we see that the $n$ indications of Dijkstra dominate just barely. So the overall running time we'll achieve is big $O(n m logn)$. Exactly the same running time we were getting for the non-negative edge length of case.\n",
    "\n",
    "### A Reweighting Technique\n",
    "Here is the twist. For each vertex v there's going to be a number $P_v$ associated with that vertex. \n",
    "The key idea behind the reweighting technique is to use these end numbers one weight per vertex, $P_v$. To use these end numbers to shift the edge lengths of the graph. I'm going to use $C'$ to denote that these shifted or transformed edge lengths. Here's the exact definition. Consider an arbitrary edge $E$ of this graph $G$. Let's say the edge goes from the tail $U$ to the head $V$. The new length, $C'_e$, is defined as the original length $C_e$. Plus the weights of these edges tail so plus $P_u$, minus the weight associated with these edges head that is minus $P_v$.\n",
    "\n",
    "\n",
    "    C'e  =  Ce + Pu - Pv\n",
    "\n",
    "\n",
    "What happens when you just add a fixed amount capital end to every edge of a graph. It doesn't work in the sense that it can change the shortest path. Why can it change the shortest path. Well, different paths have a different number of edges. So if you add some fixed amount to each edge, you change different paths by different amounts. That can screw up the shortest path. If you're lucky and all of the paths between an S and a T have exactly the same number of edges, then you shift them all by exactly the same amount and you preserve the ordering of the paths. \n",
    "\n",
    "Well, fix a graph and fix an origin vertex S and a destination vertex T. What we just learned is that when you reweight using these vertex weights, you shift every single ST path by exactly the same amount. The length of every ST path, shortest or otherwise, changes by exactly the quantity $P_S  - P_T$.\n",
    "We see that under no assumptions whatsoever about what the paths between S and T like, Note reweighting shifts every single path from ST by exactly the same quantity, the difference between PS and PT.\n",
    "\n",
    "\n",
    "\n",
    "### Johnson's Algorithm\n",
    "\n",
    "![Johnson's Algorithm](images/15_Johnsons_Algorithm.png)\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4]\n",
      "\n",
      "Shortest path [head x tail] as row x column: \n",
      "[[0 3 2 4 6]\n",
      " [inf 0 inf inf 4]\n",
      " [inf 1 0 2 4]\n",
      " [inf inf inf 0 2]\n",
      " [inf inf inf inf 0]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x119542c10>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import networkx as nx\n",
    "\n",
    "def Floyd_Warshall_APSP_dynamic(graph, A, nodes, edges, i_start_vert):\n",
    "    n = len(nodes)\n",
    "    for k in range(1, n):\n",
    "        for i in range(n):\n",
    "            for j in range(n):\n",
    "                case_1 = A[k-1][i][j]\n",
    "                case_2 = A[k-1][i][k] + A[k-1][k][j] \n",
    "                A[k][i][j] = min(case_1, case_2)\n",
    "    \n",
    "    \n",
    "def Floyd_Warshall_Algorithm(graph, start_vert): \n",
    "    nodes = list(graph.nodes)\n",
    "    edges = graph.edges.data()\n",
    "    print(nodes)\n",
    "    A = np.full((len(nodes), len(nodes), len(nodes)), None) \n",
    "    i_start_vert = nodes.index(start_vert)\n",
    "    A[0] = float('inf')\n",
    "    for diagonal in range(len(nodes)):\n",
    "        A[0][diagonal][diagonal] = 0\n",
    "    for edge in edges:\n",
    "        A[0][edge[0]][edge[1]] = edge[2]['weight']\n",
    "    Floyd_Warshall_APSP_dynamic(graph, A, nodes, edges, i_start_vert)\n",
    "    #print(\"A : \\n{}\".format(A))\n",
    "    print(\"\\nShortest path [head x tail] as row x column: \\n{}\".format(A[-1]))\n",
    "    \n",
    "\n",
    "DG = nx.DiGraph()\n",
    "for i,j in zip([0, 2, 3, 1, 4],[(0, 5), (5, 10), (10, 10), (7.5, 0), (15, 5)]):\n",
    "    DG.add_node(i, pos=j)\n",
    "DG.nodes.data()\n",
    "DG.add_weighted_edges_from([(0, 2, 2), (2, 3, 2), (3, 4, 2), (0, 1, 4), (2, 1, 1), (1, 4, 4)])\n",
    "pos = nx.get_node_attributes(DG, 'pos')\n",
    "weights = nx.get_edge_attributes(DG, 'weight')\n",
    "nx.draw_networkx_edge_labels(DG, pos, edge_labels = weights)\n",
    "nx.draw_networkx_labels(DG,pos=pos)\n",
    "nx.draw(DG, pos, with_labels = True)\n",
    "start_vert = 0\n",
    "Floyd_Warshall_Algorithm(DG, start_vert)    \n",
    "    \n",
    "   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4]\n",
      "\n",
      "Shortest path [head x tail] as row x column: \n",
      "[[0 -3 0 -6 -8]\n",
      " [inf 0 inf -3 -5]\n",
      " [inf -3 0 -6 -8]\n",
      " [inf inf inf 0 2]\n",
      " [inf inf inf 2 0]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1196643d0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Negative edges\n",
    "DG = nx.DiGraph()\n",
    "for i,j in zip([0, 2, 3, 1, 4],[(0, 5), (5, 10), (10, 10), (7.5, 0), (15, 5)]):\n",
    "    DG.add_node(i, pos=j)\n",
    "DG.nodes.data()\n",
    "DG.add_weighted_edges_from([(0, 2, 0), (2, 3, 2), (3, 4, 2), (4, 3, 2), (0, 1, 4), (2, 1, -3), (1, 4, -5)])\n",
    "pos = nx.get_node_attributes(DG, 'pos')\n",
    "weights = nx.get_edge_attributes(DG, 'weight')\n",
    "nx.draw_networkx_edge_labels(DG, pos, edge_labels = weights)\n",
    "nx.draw_networkx_labels(DG,pos=pos)\n",
    "nx.draw(DG, pos, with_labels = True)\n",
    "start_vert = 0\n",
    "Floyd_Warshall_Algorithm(DG, start_vert)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A : \n",
      "[[0 0 -6 -3 -8 0]\n",
      " [0 0 -6 -3 -8 0]]\n",
      "Bellman Ford Algorithm - Shortest path distance:\n",
      "(Johnsons, s): 0\n",
      "(Johnsons, v): 0\n",
      "(Johnsons, w): -6\n",
      "(Johnsons, x): -3\n",
      "(Johnsons, t): -8\n",
      "(Johnsons, Johnsons): 0\n",
      "Bellman Ford Algorithm Reconstructing the shortest paths: \n",
      "(Johnsons, s) : ['Johnsons', 's']\n",
      "(Johnsons, v) : ['Johnsons', 'v']\n",
      "(Johnsons, w) : ['Johnsons', 'v', 'x', 't', 'w']\n",
      "(Johnsons, x) : ['Johnsons', 'v', 'x']\n",
      "(Johnsons, t) : ['Johnsons', 'v', 'x', 't']\n",
      "(Johnsons, Johnsons) : ['Johnsons']\n",
      "\n",
      "Running Dijkstra on all paths\n",
      "\n",
      "Johnson's Algorithm : Shortest path format head : [tail: shortest path values] : \n",
      "\n",
      "s  :  {'s': 0, 'v': 0, 'w': -6, 'x': -3, 't': -8}\n",
      "v  :  {'s': inf, 'v': 0, 'w': -6, 'x': -3, 't': -8}\n",
      "w  :  {'s': inf, 'v': inf, 'w': 0, 'x': inf, 't': 2}\n",
      "x  :  {'s': inf, 'v': inf, 'w': -3, 'x': 0, 't': -5}\n",
      "t  :  {'s': inf, 'v': inf, 'w': 2, 'x': inf, 't': 0}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "-8"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import networkx as nx\n",
    "import heapq\n",
    "import numpy as np\n",
    "\n",
    "\n",
    "def djikstra_heap(DG, source):\n",
    "    #Heap implementation which does the following\n",
    "    #\n",
    "    # 1. For vertices in X, find all edges originating from them to all vertices not in X\n",
    "    # 2. Keep track of minimum value of len(w) + lwv\n",
    "    # 3. Return w, v and lwv\n",
    "    X = [source]\n",
    "    minHeap = []\n",
    "    heapq.heappush(minHeap, [0, source])\n",
    "    all_nodes = list(DG.nodes)\n",
    "    for node in all_nodes:\n",
    "        DG.nodes[node]['shortest_dist'] = float('inf')\n",
    "    while len(minHeap) != 0:\n",
    "        w = heapq.heappop(minHeap)\n",
    "        X.append(w[1])\n",
    "        DG.nodes[w[1]]['shortest_dist'] = w[0]\n",
    "        for edge in list(DG.edges):\n",
    "            if (edge[0] == w[1]) and (edge[1] not in X):  # node that has just been popped should be the tail\n",
    "                dji_greedy = w[0] + DG.edges[edge[0], edge[1]]['weight'] #djikstra's greedy criterion\n",
    "                doublenp = np.array(minHeap)\n",
    "                singlenp = []\n",
    "                if len(doublenp) == 0:\n",
    "                    heapq.heappush(minHeap, [dji_greedy, edge[1]])\n",
    "                    continue\n",
    "                else:\n",
    "                    singlenp = doublenp[:,1]\n",
    "                if edge[1] not in singlenp:\n",
    "                    heapq.heappush(minHeap, [dji_greedy, edge[1]])\n",
    "                else:\n",
    "                    dest_idx = np.where(singlenp == edge[1])\n",
    "                    if dji_greedy < int(doublenp[dest_idx][0][0]):\n",
    "                        minHeap[dest_idx[0][0]] = minHeap[0]\n",
    "                        heapq.heapify(minHeap)\n",
    "                        heapq.heappop(minHeap)\n",
    "                        heapq.heappush(minHeap, [dji_greedy, edge[1]])\n",
    "    shortest_path_dict = {}\n",
    "    for node in all_nodes:\n",
    "        shortest_path_dict[node] = DG.nodes[node]['shortest_dist']\n",
    "    return shortest_path_dict\n",
    "\n",
    "        \n",
    "    \n",
    "def Johnsons_Algorithm(graph): \n",
    "    nodes = list(graph.nodes)\n",
    "    graph_prime = graph.copy(as_view=False)\n",
    "    graph_prime.add_node('Johnsons')\n",
    "    j_edges_add = []\n",
    "    for node in nodes:\n",
    "        j_edges_add.append(('Johnsons', node, 0))\n",
    "    graph_prime.add_weighted_edges_from(j_edges_add)\n",
    "    j_start_vert = 'Johnsons'\n",
    "    bellman_Pv = Bellman_Ford_Algorithm_optimize(graph_prime, j_start_vert)    \n",
    "    if bellman_Pv == False:\n",
    "        return False\n",
    "    graph_prime_dij = graph.copy(as_view=False)\n",
    "    for e in graph_prime_dij.edges:\n",
    "        Pu = bellman_Pv[0][bellman_Pv[1].index(e[0])]\n",
    "        Pv = bellman_Pv[0][bellman_Pv[1].index(e[1])]\n",
    "        graph_prime_dij[e[0]][e[1]]['weight'] = graph[e[0]][e[1]]['weight'] + Pu - Pv\n",
    "    apsp = {}\n",
    "    for node in nodes:\n",
    "        shortest_dict = djikstra_heap(graph_prime_dij, node)\n",
    "        apsp[node] = shortest_dict\n",
    "    print(\"\\nRunning Dijkstra on all paths\")\n",
    "    print(\"\\nJohnson\\'s Algorithm : Shortest path format head : [tail: shortest path values] : \\n\")\n",
    "    shortest_shortest_apsp = float('inf')\n",
    "    for source, dest in apsp.items():\n",
    "        for d in dest:\n",
    "            Pu = bellman_Pv[0][bellman_Pv[1].index(source)]\n",
    "            Pv = bellman_Pv[0][bellman_Pv[1].index(d)]\n",
    "            dest[d] -= (Pu - Pv) \n",
    "            if shortest_shortest_apsp > dest[d]:\n",
    "                shortest_shortest_apsp = dest[d]\n",
    "        print(\"{}  :  {}\".format(source, dest))\n",
    "    return shortest_shortest_apsp\n",
    "        \n",
    "        \n",
    "\n",
    "DG = nx.DiGraph()\n",
    "for i,j in zip(['s', 'v', 'w', 'x', 't'],[(0, 5), (5, 10), (10, 10), (7.5, 0), (15, 5)]):\n",
    "    DG.add_node(i, pos=j)\n",
    "DG.nodes.data()\n",
    "DG.add_weighted_edges_from([('s', 'v', 0), ('v', 'w', 2), ('w', 't', 2), ('t', 'w', 2), ('s', 'x', 4), ('v', 'x', -3), ('x', 't', -5)])\n",
    "pos = nx.get_node_attributes(DG, 'pos')\n",
    "weights = nx.get_edge_attributes(DG, 'weight')\n",
    "nx.draw_networkx_edge_labels(DG, pos, edge_labels = weights)\n",
    "nx.draw_networkx_labels(DG,pos=pos)\n",
    "nx.draw(DG, pos, with_labels = True)\n",
    "Johnsons_Algorithm(DG)            \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Challenge problem\n",
    "\n",
    "In this assignment you will implement one or more algorithms for the all-pairs shortest-path problem. Here are data files describing three graphs:\n",
    "\n",
    "g1.txt <br>\n",
    "g2.txt <br>\n",
    "g3.txt <br>\n",
    "\n",
    "The first line indicates the number of vertices and edges, respectively. Each subsequent line describes an edge (the first two numbers are its tail and head, respectively) and its length (the third number). NOTE: some of the edge lengths are negative. NOTE: These graphs may or may not have negative-cost cycles.\n",
    "\n",
    "Your task is to compute the \"shortest shortest path\". Precisely, you must first identify which, if any, of the three graphs have no negative cycles. For each such graph, you should compute all-pairs shortest paths and remember the smallest one (i.e., compute minu,v∈Vd(u,v), where d(u,v)d(u,v) denotes the shortest-path distance from uu to vv).\n",
    "\n",
    "If each of the three graphs has a negative-cost cycle, then enter \"NULL\" in the box below. If exactly one graph has no negative-cost cycles, then enter the length of its shortest shortest path in the box below. If two or more of the graphs have no negative-cost cycles, then enter the smallest of the lengths of their shortest shortest paths in the box below.\n",
    "\n",
    "OPTIONAL: You can use whatever algorithm you like to solve this question. If you have extra time, try comparing the performance of different all-pairs shortest-path algorithms!\n",
    "\n",
    "OPTIONAL: Here is a bigger data set to play with.\n",
    "\n",
    "large.txt\n",
    "For fun, try computing the shortest shortest path of the graph in the file above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/aishwaya/anaconda2/lib/python2.7/site-packages/urllib3/connectionpool.py:858: InsecureRequestWarning: Unverified HTTPS request is being made. Adding certificate verification is strongly advised. See: https://urllib3.readthedocs.io/en/latest/advanced-usage.html#ssl-warnings\n",
      "  InsecureRequestWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error: Negative Cycle detected in graph. Bellman-Ford Algorithm does not allow negative cycle.\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "import urllib3\n",
    "\n",
    "def testcase_Johnsons_Algorithm(url):\n",
    "    challenge_graph = nx.DiGraph()\n",
    "    http = urllib3.PoolManager()\n",
    "    r1 = http.request('GET', url)\n",
    "    IntegerMatrixStringJoin = r1.data.split('\\n')\n",
    "    IntegerMatrixStringJoin.remove('')\n",
    "    IntegerMatrixStringJoin.remove(IntegerMatrixStringJoin[0])\n",
    "    edges = []\n",
    "    for i in IntegerMatrixStringJoin:\n",
    "        node_edges = i.split(' ')\n",
    "        source = int(node_edges[0])\n",
    "        dest = int(node_edges[1])\n",
    "        length = int(node_edges[2])\n",
    "        edges.append((source, dest, length))\n",
    "    challenge_graph.add_weighted_edges_from(edges)\n",
    "    output = Johnsons_Algorithm(challenge_graph)\n",
    "    return output\n",
    "\n",
    "\n",
    "theShortest_1 = testcase_Johnsons_Algorithm(\"https://d3c33hcgiwev3.cloudfront.net/_6ff856efca965e8774eb18584754fd65_g1.txt?Expires=1563753600&Signature=YqYz0G2RbRlyP5ngWX3asdswxfl-cPVaCfQJsGO7QTTmiD-9IUMAhUXhwg3hWpM07ScNLMZbmLOZSJ-xiXxuhQ-Bv6Fh3iaynBbO6PcePuK5IiiC-FABD0FAMzG4FHoOkRaVjUN4fPIvHlEql1l6vRwvb08ikP-0Fhu-mTVVOIg_&Key-Pair-Id=APKAJLTNE6QMUY6HBC5A\")\n",
    "print(theShortest_1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/aishwaya/anaconda2/lib/python2.7/site-packages/urllib3/connectionpool.py:858: InsecureRequestWarning: Unverified HTTPS request is being made. Adding certificate verification is strongly advised. See: https://urllib3.readthedocs.io/en/latest/advanced-usage.html#ssl-warnings\n",
      "  InsecureRequestWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error: Negative Cycle detected in graph. Bellman-Ford Algorithm does not allow negative cycle.\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "theShortest_2 = testcase_Johnsons_Algorithm(\"https://d3c33hcgiwev3.cloudfront.net/_6ff856efca965e8774eb18584754fd65_g2.txt?Expires=1563753600&Signature=juXaK53FZXP1lSOQvp0Ua66awjspln8U8nlKfFTeVVXoIrWCbSCF3HsPnoNrEcWL8T75zuojljJKAANQuRXMiJqQFiBLHxdPRWIpzn3fZloyPLFAA6pjW~opvnSmtp8AjzpyBo6k6kLXiFG-3hfh04iD0YDCZ1yPD6QFm3-fxPc_&Key-Pair-Id=APKAJLTNE6QMUY6HBC5A\")\n",
    "print(theShortest_2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "theShortest_3 = testcase_Johnsons_Algorithm(\"https://d3c33hcgiwev3.cloudfront.net/_6ff856efca965e8774eb18584754fd65_g3.txt?Expires=1563753600&Signature=AoYxvyMKw2049fwxXNoD0P3lPSx6htEF~19olrYhvkFiRGmKo0RuaoDmDmr1-mUa~5EKN34PjSEER32XINHHLZlFVfCFZ7U-0aTNPjXoV8xsplG4PoiJegxEhnmQ20K1F7yZtLfwyv98iE1tMhH1utXE7Ls0EWV5qgM0TKS64a8_&Key-Pair-Id=APKAJLTNE6QMUY6HBC5A\")\n",
    "print(theShortest_3)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-19"
   ]
  },
  {
   "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}