Still improving description

Author: Taras Nikulin

Dijkstra Algorithm/README.md

@@ -1,30 +1,40 @@
-# Dijkstra-algorithm
+# Dijkstra's algorithm
 
 This algorithm was invented in 1956 by Edsger W. Dijkstra. 
 
 This algorithm can be used, when you have one source vertex and want to find the shortest paths to all other vertices in the graph.
 
 The best example is road network. If you wnat to find the shortest path from your house to your job, then it is time for the Dijkstra's algorithm.
 
-I have a gif example, which will show you how algorithm works. If this is not enough, then you can play with my **VisualizedDijkstra.playground**.
-So let's image, that your house is "A" vertex and your job is "B" vertex. And you are lucky, you have graph with all possible routes.
+I have created **VisualizedDijkstra.playground** to help you to understand, how this algorithm works. Besides, I have described below step by step how does it works.
+
+So let's imagine, that your house is "A" vertex and your job is "B" vertex. And you are lucky, you have graph with all possible routes.
+
+> Initialization
+
 When the algorithm starts to work initial graph looks like this:
 
 <img src="Images/image1.png" height="250" />
 
-The table below will represent graph state
+The table below represents graph state:
 
 |                           |  A  |  B  |  C  |  D  |  E  |
 |:------------------------- |:---:|:---:|:---:|:---:|:---:|
 | Visited                   |  F  |  F  |  F  |  F  |  F  |
 | Path Length From Start    | inf | inf | inf | inf | inf |
 | Path Vertices From Start  | [ ] | [ ] | [ ] | [ ] | [ ] |
 
-Graph's array contains 5 vertices [A, B, C, D, E].
-Let's assume, that edge weight it is path length in kilometers between vertices.
-A vertex has neighbors: B(path from A: 5.0), C(path from A: 0.0), D(path from A: 0.0)
-And because algorithm has done nothing, then all vertices' path length from source vertex values are infinity (think about infinity as "I don't know, how long will it takes to get this vertex from source one")
-Finally we have to set source vertex path length from source vertex to 0.
+_inf is equal infinity, which basically means, that algorithm doesn't know how far away is this vertex from start one._
+_F states for False_
+_T states for True_
+
+To initialize out graph we have to set source vertex path length from source vertex to 0.
+
+|                           |  A  |  B  |  C  |  D  |  E  |
+|:------------------------- |:---:|:---:|:---:|:---:|:---:|
+| Visited                   |  F  |  F  |  F  |  F  |  F  |
+| Path Length From Start    |  0  | inf | inf | inf | inf |
+| Path Vertices From Start  | [ ] | [ ] | [ ] | [ ] | [ ] |
 
 Great, now our graph is initialized and we can pass it to the Dijkstra's algorithm.
 
@@ -37,34 +47,51 @@ Cycle:
 When all vertices are marked as visited, the algorithm's job is done. Now, you can see the shortest path from the start for every vertex by pressing the one you are interested in.
 
 Okay, let's start!
-From now we will keep array which contains non visited vertices. Here they are:
-var nonVisitedVertices = [A, B, C, D, E]
-Let's follow the algorithm and pick the first vertex, which neighbors we want to check.
-Imagine that we have function, that returns vertex with smallest path length from start.
-var checkingVertex = nonVisitedVertices.smallestPathLengthFromStartVertex()
-Then we set this vertex as visited 
+Let's follow the algorithm's cycle and pick the first vertex, which neighbors we want to check.
+All our vertices are not visited, but there is only one have the smallest path length from start - A. This vertex is th first one, which neighbors we will check.
+First of all, set this vertex as visited 
+
+A.visited = true
+
+<img src="Images/image2.png" height="250" />
+
+After this step graph has this state:
 
 |                           |  A  |  B  |  C  |  D  |  E  |
 |:------------------------- |:---:|:---:|:---:|:---:|:---:|
 | Visited                   |  T  |  F  |  F  |  F  |  F  |
 | Path Length From Start    |  0  | inf | inf | inf | inf |
 | Path Vertices From Start  | [A] | [ ] | [ ] | [ ] | [ ] |
 
-checkingVertex.visited = true
-
-<img src="Images/image2.png" height="250" />
+> Step 1
 
 Then we check all of its neighbors. 
-If neighbor's path length from start is bigger than checking vertex path length from start + edge weigth, then we set neighbor's path length from start new value and append to its pathVerticesFromStart array new vertex: checkingVertex. Repeat this action for every vertex.
+If checking vertex path length from start + edge weigth is smaller than neighbor's path length from start, then we set neighbor's path length from start new value and append to its pathVerticesFromStart array new vertex: checkingVertex. Repeat this action for every vertex.
+
+for clarity:
+```swift
+if (A.pathLengthFromStart + AB.weight) < B.pathLengthFromStart {
+    B.pathLengthFromStart = A.pathLengthFromStart + AB.weight
+    B.pathVerticesFromStart = A.pathVerticesFromStart
+    B.pathVerticesFromStart.append(B)
+}
+```
+And now our graph looks like this one:
 
 <img src="Images/image3.png" height="250" />
 
+And its state is here:
+
 |                           |     A      |     B      |     C      |     D      |     E      |
 |:------------------------- |:----------:|:----------:|:----------:|:----------:|:----------:|
 | Visited                   |     T      |     F      |     F      |     F      |     F      |
 | Path Length From Start    |     0      |     3      |    inf     |     1      |    inf     |
 | Path Vertices From Start  |    [A]     |   [A, B]   |    [ ]     |   [A, D]   |    [ ]     |
 
+> Step 2
+
+From now we repeat all actions again and fill our table with new info! 
+
 <img src="Images/image4.png" height="250" />
 
 |                           |     A      |     B      |     C      |     D      |     E      |
@@ -73,6 +100,8 @@ If neighbor's path length from start is bigger than checking vertex path length
 | Path Length From Start    |     0      |     3      |    inf     |     1      |     2      |
 | Path Vertices From Start  |    [A]     |   [A, B]   |    [ ]     |   [A, D]   | [A, D, E]  |
 
+> Step 3
+
 <img src="Images/image5.png" height="250" />
 
 |                           |     A      |     B      |     C      |     D      |     E      |
@@ -81,6 +110,8 @@ If neighbor's path length from start is bigger than checking vertex path length
 | Path Length From Start    |     0      |     3      |     11     |     1      |     2      |
 | Path Vertices From Start  |    [A]     |   [A, B]   |[A, D, E, C]|   [A, D]   | [A, D, E ] |
 
+> Step 4
+
 <img src="Images/image6.png" height="250" />
 
 |                           |     A      |     B      |     C      |     D      |     E      |
@@ -89,8 +120,12 @@ If neighbor's path length from start is bigger than checking vertex path length
 | Path Length From Start    |     0      |     3      |     8      |     1      |     2      |
 | Path Vertices From Start  |    [A]     |   [A, B]   |   [A, B, C]|   [A, D]   | [A, D, E ] |
 
+> Step 5
+
 <img src="Images/image7.png" height="250" />
 
+> Step 6
+
 |                           |     A      |     B      |     C      |     D      |     E      |
 |:------------------------- |:----------:|:----------:|:----------:|:----------:|:----------:|
 | Visited                   |     T      |     T      |     T      |     T      |     T      |