Fix typos

Author: Hai Nguyen

All-Pairs Shortest Paths/README.markdown

@@ -1,14 +1,14 @@
 # All-Pairs Shortest Paths
 
-The All-Pairs shortest path problem simultaneously computes the shortest path from each node in the graph to each other node, provded a path exists for each pair. In the naive approach, we could simply compute a single-source shortest path from each node to each other node. The number of shortest paths computed is then bound by `O(V^2)`, where `V` is the number of vertices in the graph. Because SSSP is also bounded by `O(V^2)`, the total running time for the naive approach would be `O(V^4)`.
+The All-Pairs shortest path problem simultaneously computes the shortest path from each node in the graph to each other node, provided a path exists for each pair. In the naive approach, we could simply compute a single-source shortest path from each node to each other node. The number of shortest paths computed is then bound by `O(V^2)`, where `V` is the number of vertices in the graph. Because SSSP is also bounded by `O(V^2)`, the total running time for the naive approach would be `O(V^4)`.
 
-However, by applying a dynamic approach on the adjacency matrix of the graph, a running time of `Θ(V^3)` is achievable, using the `Floyd-Warshall` algorithm. Floyd-Warshall iterates through an adjacency matrix, and for each pair of start(`i`) and end(`j`) vertices it considers if the current distance between them is greater than a path taken through another vertex(`k`) in the graph (if paths `i` ~> `k` and `k` ~> `j` exist). It moves through an adjacency matrix for every vertex `k` applying its comparison for each pair (`i`, `j`), so for each `k` a new adjacency matrix `D(k)` is derived, where each value `d(k)[i][j]` is defined as:
+However, by applying a dynamic approach on the adjacency matrix of the graph, a running time of `O(V^3)` is achievable, using the `Floyd-Warshall` algorithm. Floyd-Warshall iterates through an adjacency matrix, and for each pair of start(`i`) and end(`j`) vertices it considers if the current distance between them is greater than a path taken through another vertex(`k`) in the graph (if paths `i` ~> `k` and `k` ~> `j` exist). It moves through an adjacency matrix for every vertex `k` applying its comparison for each pair (`i`, `j`), so for each `k` a new adjacency matrix `D(k)` is derived, where each value `d(k)[i][j]` is defined as:
 
 <img src="img/weight_comparison_formula.png" width="400px" />
 
-where `w[i][j]` is the weight of the edge connecting vertex `i` to vertex `j` in the graph's original adjacency matrix. 
+where `w[i][j]` is the weight of the edge connecting vertex `i` to vertex `j` in the graph's original adjacency matrix.
 
-When the algorithm memoizes each refined adjacency and predecessor matrix, its space complexity is `Θ(V^3)`, which can be optimised to `Θ(V^2)` by only memoizing the latest refinements. Reconstructing paths is a recursive procedure which requires `Θ(V)` time and `Θ(V^2)` space.
+When the algorithm memoizes each refined adjacency and predecessor matrix, its space complexity is `O(V^3)`, which can be optimised to `O(V^2)` by only memoizing the latest refinements. Reconstructing paths is a recursive procedure which requires `O(V)` time and `O(V^2)` space.
 
 # Example
 
@@ -22,9 +22,9 @@ the adjacency matrix representation `w` is
 
 ### Calculating shortest paths' weights
 
-At the beginning of the algorithm, `D(0)` is the same as `w`, with the following exceptions to accomodate the comparison function:
+At the beginning of the algorithm, `D(0)` is the same as `w`, with the following exceptions to accommodate the comparison function:
 
-1. vertices with no path connecting them have the `ø` replaced with `∞` 
+1. vertices with no path connecting them have the `ø` replaced with `∞`
 2. the diagonal has all `0`s
 
 Here are all the adjacency matrices derived when perform Floyd-Warshall on the above graph:
@@ -56,7 +56,7 @@ This algorithm finds only the lengths of the shortest paths between all pairs of
 
 # Project Structure
 
-The provided xcworkspace allows working in the playground, which imports the APSP framework target from the xcodeproj. Build the framework target and rerun the playground to get started. There is also a test target in the xcodeproj. 
+The provided xcworkspace allows working in the playground, which imports the APSP framework target from the xcodeproj. Build the framework target and rerun the playground to get started. There is also a test target in the xcodeproj.
 
 In the framework:
 
@@ -65,12 +65,12 @@ In the framework:
 
 # TODO
 
-- Implement naive `Θ(V^4)` method for comparison
+- Implement naive `O(V^4)` method for comparison
 - Implement Johnson's algorithm for sparse graphs
 - Implement other cool optimized versions
 
 # References
 
 Chapter 25 of Introduction to Algorithms, Third Edition by Cormen, Leiserson, Rivest and Stein [https://mitpress.mit.edu/books/introduction-algorithms](https://mitpress.mit.edu/books/introduction-algorithms)
 
-*Written for Swift Algorithm Club by [Andrew McKnight](https://github.com/armcknight)*
+*Written for Swift Algorithm Club by [Andrew McKnight](https://github.com/armcknight)*