minor changes

Author: NikitaSharma1

content/algorithms/Dijkstra/Dijkstra.ipynb

@@ -26,7 +26,7 @@
    "metadata": {},
    "source": [
     "Let's say you want to travel from Delhi(DEL), India to London(LCY), UK via flights that have various routes with different stops, namely, Frankfurt(FRA), Zurich(ZRH), Amsterdam(AMS), Geneva(GVA) and Dublin(DUB). Now, you want to find the shortest path as you are in a hurry and want to get to London as soon as possible.<br> \n",
-    "An important thing to know is that any subpath from C -> E of the shortest path A -> E is also the shortest path from node C to node E. That means not only we'll get the shortest path from Delhi to London but also to other stops from Delhi.\n",
+    "An important thing to know is that any subpath from C $\\rightarrow$ E of the shortest path A $\\rightarrow$ E is also the shortest path from node C to node E. That means not only one will get the shortest path from Delhi to London but also to other stops from Delhi.\n",
     "\n",
     "<b>ASSUMPTIONS</b>\n",
     "- Distance taken is imaginary.\n",
@@ -84,13 +84,13 @@
     "## Dijkstra's Algorithm\n",
     "\n",
     "Dijkstra's algorithm is used to find the shortest path between nodes or commonly from one source node to every other node in the graph, where edge weight represents the cost/ distance between 2 nodes in the case of a weighted graph. It can work with both directed and undirected graphs, but <b>it is not suitable for graphs with NEGATIVE edges.</b><br>\n",
-    "Time complexity of Dijkstra's algorithm is $O(V^{2})$, but with minimum priority queue, it comes down to $O(V + E log V)$\n",
+    "Time complexity of Dijkstra's algorithm is $O(\\ V^{2})$, but with minimum priority queue, it comes down to $O(\\ V + E\\text{ log } V\\ )$\n",
     "\n",
     "### Algorithm\n",
     "\n",
     "1. Convert your problem into a graph equivalent.\n",
     "2. Create a list of unvisited vertices. \n",
-    "3. Assign the starting point as source node with distance(cost)= 0 and other node's distance as infinity.\n",
+    "3. Assign the starting point as source node with <b>distance(cost)= 0</b> and other node's distance as infinity.\n",
     "4. For every unvisited neighbour, calculate the minimum distance from the current node.\n",
     "5. The new distance is calculated as `minimum(current distance, distance of previous node + edge weight)`\n",
     "6. When all the neighbours have been visited, remove the node from the unvisited list and select the next node with the minimum distance.\n",
@@ -102,17 +102,17 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Let's look at the example of the directed graph we were talking about. But, before moving forward, here are some things you should keep in mind. In the following graphs, edge weight defines the distance between 2 nodes, black edge represents unvisited edges, red represents edges that are being traversed, and green represents visited edges. Let's begin!!"
+    "Let's look at the example of the directed graph mentioned above. But, before moving forward, here are some things one should keep in mind. In the following graphs, edge weight defines the distance between 2 nodes, black edge represents unvisited edges, red represents edges that are being traversed, and green represents visited edges. Let's begin!!"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "According to Dijkstra's algorithm,\n",
-    "- First, we'll assign all stops(nodes) infinite values except the source node (DEL in our case as our path starts from Delhi), which is assigned a value of 0. This is because we are assuming that we are not aware of the distance one needs to cover to reach other nodes and hence assign it the maximum value possible. (fig. 1)\n",
-    "- Dijkstra is based on the greedy approach, which means we'll select the node with the minimum distance, which is DEL having a distance of 0 units, and this approach is being followed in the whole process.\n",
-    "- The next step is to start traversing the neighbours of DEL and update the distance of all neighbouring nodes as you can see in fig. 2. While updating the distance, always keep in mind that the updated distance should be `minimum(current distance, distance of previous node + edge weight)`. Like, \n",
+    "- First, assign all stops(nodes) infinite values except the source node (DEL in this case as the path starts from Delhi), which is assigned a value of 0. This is because the distance one needs to cover to reach other nodes is assumed to be unknown and, hence maximum value possible is being assigned. (fig. 1)\n",
+    "- Dijkstra is based on the greedy approach, which means one needs to select the node with the minimum distance, which is DEL having a distance of 0 units, and this approach is being followed in the whole process.\n",
+    "- The next step is to start traversing the neighbours of DEL and update the distance of all neighbouring nodes as shown in fig. 2. While updating the distance, always keep in mind that the updated distance should be `minimum(current distance, distance of previous node + edge weight)`. Like, \n",
     "    - DUB : `min(infinity, 7) = 7`\n",
     "    - FRA : `min(infinity, 6) = 6`\n",
     "    - ZRH : `min(infinity, 5) = 5`"
@@ -122,7 +122,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "![Figure 1&2](Graphs/figure1_2.png \"Title\")"
+    "![Figure 1&2](Graphs/figure1_2.png \"Figure 1 and Figure 2\")"
    ]
   },
   {
@@ -141,14 +141,14 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "![Figure 3&4](Graphs/figure3_4.png \"Title\")"
+    "![Figure 3&4](Graphs/figure3_4.png \"Figure 3 and Figure 4\")"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "- Here, we have 2 nodes with minimum distance (7 units), AMS and DUB. So, let's update their neighbours one by one.(fig. 5)\n",
+    "- Here, 2 nodes are left with minimum distance (7 units), AMS and DUB. So, let's update their neighbours one by one.(fig. 5)\n",
     "    - DUB :\n",
     "        - AMS : `min(7, 7+2) = 7`\n",
     "        - LCY : `min(9, 7+4) = 9`\n",
@@ -157,18 +157,18 @@
     "- Among the last 2 nodes, our destination is LCY. So, last update is for GVA's neighbour.\n",
     "    - LCY : `min(9, 8+1) = 9`\n",
     "    \n",
-    "Figure 6 shows us the final graph with shortest distance to each node from DEL(source node) and it comes out that the shortest distance to LCY from DEL is 9 units which have 2 paths:<br>\n",
+    "Figure 6 shows the final graph with shortest distance to each node from DEL(source node) and it comes out that the shortest distance to LCY from DEL is 9 units which have 2 paths:<br>\n",
     "- (DEL -> FRA -> LCY) <br>\n",
     "- (DEL -> ZRH -> GVA -> LCY)\n",
     "\n",
-    "So, now we know that one can take any of these paths to reach as soon as possible. But, in case there are more than one path like in this situation, <b>dijkstra's algorithm returns the shortest path with minimum number of edges. </b>"
+    "So, one can take any of these paths to reach as soon as possible. But, in case there are more than one path like in this situation, <b>dijkstra's algorithm returns the shortest path with minimum number of edges. </b>"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "![Figure 5&6](Graphs/figure5_6.png \"Title\")"
+    "![Figure 5&6](Graphs/figure5_6.png \"Figure 5 and Figure 6\")"
    ]
   },
   {
@@ -182,7 +182,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "In our example the number of nodes were less and it wasn't that complicated, but, in real life problems, there can be a lot of nodes and thus, it is needed to maintain proper record. Let's see our example in NetworkX implementation."
+    "In the previous example the number of nodes were less and it wasn't that complicated, but, in real life problems, there can be a lot of nodes and thus, it is needed to maintain proper record. Let's see the example in NetworkX implementation."
    ]
   },
   {
@@ -205,10 +205,10 @@
     "from itertools import count\n",
     "\n",
     "'''\n",
-    "So, we already have our graph 'flight_path' with all nodes and edges. Now, before implementing the algorithm, \n",
-    "we first need to make the data available in the proper format to access.\n",
+    "So, the graph 'flight_path' is already defined with all nodes and edges. Now, before implementing the algorithm, \n",
+    "one first needs to make the data available in the proper format to access.\n",
     "\n",
-    "The first thing to do is to have a dictionary with every node as keys and (connecting node, weight) as values so that we can \n",
+    "The first thing to do is to have a dictionary with every node as keys and (connecting node, weight) as values so that one can\n",
     "traverse easily.\n",
     "'''\n",
     "flight_succ = flight_path._succ if flight_path.is_directed() else flight_path._adj\n",
@@ -220,7 +220,7 @@
     "weight = _weight_function(flight_path, \"weight\")\n",
     "\n",
     "'''\n",
-    "The next step is to define various dictionaries so that we can store and track all nodes path.\n",
+    "The next step is to define various dictionaries to store and track all nodes path.\n",
     "'''\n",
     "dist = {}  # dictionary of final distances\n",
     "seen = {}  # dictionary of visited nodes with recent shortest distance\n",
@@ -241,7 +241,7 @@
     "push(fringe, (0, next(c), source))\n",
     "\n",
     "'''\n",
-    "It's time to start traversing our graph starting from source node.\n",
+    "It's time to start traversing the graph starting from source node.\n",
     "'''\n",
     "\n",
     "while fringe: \n",
@@ -252,7 +252,7 @@
     "        if v == target: \n",
     "            break\n",
     "           \n",
-    "        # Now, we are traversing the neighbours of the node\n",
+    "        # traversing the neighbours of the node\n",
     "        for u, e in flight_succ[v].items(): \n",
     "            distance = weight(v, u, e)\n",
     "            \n",
@@ -262,8 +262,8 @@
     "            vu_dist = dist[v] + distance \n",
     "            \n",
     "            '''\n",
-    "            If u is already in dist then there can be 2 cases, either our graph has negative cycle or we might\n",
-    "            have found another shortest path to u.\n",
+    "            If u is already in dist then there can be 2 cases, either the graph has negative cycle or there might\n",
+    "            be another shortest path to u.\n",
     "            '''\n",
     "            if u in dist:\n",
     "                u_dist = dist[u]\n",
@@ -277,7 +277,7 @@
     "                if paths is not None:\n",
     "                    paths[u] = paths[v] + [u]\n",
     "\n",
-    "# printing the distance and path from our source node 'DEL' to target node 'LCY'                    \n",
+    "# printing the distance and path from the source node 'DEL' to target node 'LCY'                    \n",
     "print(dist[target], paths[target])"
    ]
   },
@@ -287,7 +287,7 @@
    "source": [
     "Don't worry, you don't need to write all this code again and again. NetworkX got you covered!! So, NetworkX provides a lot of functions with the help of which one can actually find the [shortest path](https://networkx.org/documentation/stable/reference/algorithms/shortest_paths.html) based on their needs. \n",
     "\n",
-    "All functions using dijkstra's algorithm are similar, but, for our example the most suitable is [single_source_dijkstra()](https://networkx.org/documentation/stable/reference/algorithms/generated/networkx.algorithms.shortest_paths.weighted.single_source_dijkstra.html#networkx.algorithms.shortest_paths.weighted.single_source_dijkstra). It comes out that this function actually give us the same output as we calculated in our example."
+    "All functions using dijkstra's algorithm are similar, but, for this example the most suitable is [single_source_dijkstra()](https://networkx.org/documentation/stable/reference/algorithms/generated/networkx.algorithms.shortest_paths.weighted.single_source_dijkstra.html#networkx.algorithms.shortest_paths.weighted.single_source_dijkstra). It comes out that this function actually gives the same output as the one calculated in the above example."
    ]
   },
   {
@@ -319,8 +319,8 @@
     "It is used as a part of applications to find the shortest path if required. There are other factors as well which are considered in every application while implementing Dijkstra's algorithm. Like,\n",
     "- In special drones or robots for delivery service, it is used as a part to identify the shortest path possible.\n",
     "- One of the most common use case is Google Maps. It helps to find the best route possible in shortest time.\n",
-    "- In social media applications, for smaller graphs it can be used effectively to suggest you \"people you may know\" section.\n",
-    "- As our example, it can be used in a software which calculates and informs the estimate arrival time, best route etc. of a flight to a user.\n",
+    "- In social media applications, for smaller graphs it can be used effectively to suggest the \"people you may know\" section.\n",
+    "- As the above example, it can be used in a software which calculates and informs the estimate arrival time, best route etc. of a flight to a user.\n",
     "- It is used in IP routing to find Open shortest Path First.\n",
     "- It is used in the telephone network."
    ]
@@ -340,6 +340,16 @@
     "- It cannot handle negative weights which leads to acyclic graphs and most often cannot obtain the right shortest path.\n",
     "- It is a greedy algorithm that means it is possible for the algorithm to select the current best option which can make the algorithm get sidetracked following a potential path that doesn’t exist, simply because the edges along it form a short path."
    ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Reference\n",
+    "\n",
+    "Shivani Sanan, Leena jain, Bharti Kappor (2013). (IJAIEM) \"Shortest Path Algorithm\" <br>\n",
+    "https://www.ijaiem.org/volume2issue7/IJAIEM-2013-07-23-079.pdf"
+   ]
   }
  ],
  "metadata": {