Merge branch 'develop'

Author: codejsha

README.md

@@ -227,6 +227,8 @@ MutableValueGraph<City, Distance> roads = ValueGraphBuilder.directed()
 
 **Graph algorithms**
 
+> NOTE: In the following, the C++ implementations are currently only available on MSVC.
+
 - A\* search algorithm, CCSP#2.2.5: A single-pair shortest path algorithm. This is a variant of Dijkstra's algorithm using heuristics to try to speed up the search.
 - Bellman-Ford algorithm, CLRS#24.1: [c++](cpp-algorithm/src/cpp-algorithm/src/graph/bellman_ford.h), [java#1](java-algorithm/src/main/java/com/example/algorithm/graph/BellmanFord1.java), [java#2](java-algorithm/src/main/java/com/example/algorithm/graph/BellmanFord2.java) | A single source the shortest path algorithm that can handle negative edge weights. It finds the shortest path from a source vertex to all other vertices in a weighted graph.
 
@@ -387,6 +389,8 @@ algorithm Prim(G, root):
 
 **Examples**
 
+> NOTE: In the following, the C++ implementations are currently only available on MSVC.
+
 - Maze problem: [java](java-algorithm/src/main/java/com/example/algorithm/graph/MazeProblem.java) | A maze problem is that find a path from the start to the goal. The maze is represented by a graph. The start and the goal are represented by vertices. The path is represented by a sequence of vertices.
 - Minimum spanning tree (Kruskal, Prim, Boruvka), CLRS#23, CCSP#4.4.2: [python(test)](python-algorithm/algorithm/graph/test/test_minimum_spanning_tree.py) | Find the minimum spanning tree of a graph. cf. Kruskal(CLRS#23.2, CLRS#21.1), Prim(CLRS#23.2)
 

cpp-algorithm/src/array/advancing_through.cpp

@@ -2,13 +2,13 @@
 
 auto AdvancingThrough::CanReachEnd(const std::vector<int>& max_advance_steps) -> bool
 {
-    auto furthest_reach_so_far = 0;
-    const auto last_index = static_cast<int>(max_advance_steps.size()) - 1;
+    int reach_so_far = 0;   // furthest reach so far
+    const int last_index = static_cast<int>(max_advance_steps.size()) - 1;
 
-    for (int i = 0; i <= furthest_reach_so_far && furthest_reach_so_far < last_index; ++i)
+    for (int i = 0; i <= reach_so_far && reach_so_far < last_index; ++i)
     {
-        furthest_reach_so_far = std::max(furthest_reach_so_far, max_advance_steps[i] + i);
+        reach_so_far = std::max(reach_so_far, max_advance_steps[i] + i);
     }
 
-    return furthest_reach_so_far >= last_index;
+    return reach_so_far >= last_index;
 }