From e6558351a88270f2e3d949dd7b63728b553babfb Mon Sep 17 00:00:00 2001
From: fhl43211 <fhl43211@gmail.com>
Date: Fri, 21 Feb 2020 09:06:58 -0800
Subject: [PATCH] Use lambda function

---
 .../c++11/01_dijkstras_algorithm.cpp          | 66 ++++++++++---------
 1 file changed, 34 insertions(+), 32 deletions(-)

diff --git a/07_dijkstras_algorithm/c++11/01_dijkstras_algorithm.cpp b/07_dijkstras_algorithm/c++11/01_dijkstras_algorithm.cpp
index 3998393..f0e069d 100644
--- a/07_dijkstras_algorithm/c++11/01_dijkstras_algorithm.cpp
+++ b/07_dijkstras_algorithm/c++11/01_dijkstras_algorithm.cpp
@@ -3,51 +3,51 @@
 #include <string>
 #include <vector>
 #include <limits>
-#include <algorithm>
 
-namespace
+int main(void)
 {
   using node_t = std::string;
   using node_cost_t = std::unordered_map<node_t, unsigned>;
   using graph_t = std::unordered_map<node_t, node_cost_t>;
   using parent_graph_t = std::unordered_map<node_t, node_t>;
 
-  std::vector<std::string> processed;
-  auto max = std::numeric_limits<unsigned>::max();
-  const node_t find_lowest_cost_node(const node_cost_t& costs)
-  {
-    auto lowest_cost = max;
-    node_t lowest_cost_node{};
-    // Go through each node in the costs graph
-    for (const auto& nodeCost : costs)
-    {
-      const auto& cost = nodeCost.second;
-      const auto& node = nodeCost.first;
-      // Check if this node is processed or not;
-      bool isNotProcessed = std::find(processed.cbegin(), processed.cend(), node) == processed.cend();
-      // Find the lowest cost node
-      if (cost < lowest_cost && isNotProcessed)
-      {
-        lowest_cost = cost;
-        lowest_cost_node = node;
-      }
-    }
-    return lowest_cost_node;
-  }
-}
-
-int main(void)
-{
   // Setup graph
   graph_t graph;
+  graph.reserve(4U);
   graph.emplace("start", node_cost_t{{"a", 6}, {"b", 2}});
   graph.emplace("a", node_cost_t{{"finish", 1}});
   graph.emplace("b", node_cost_t{{"a", 3},{"finish", 5}});
   graph.emplace("finish", node_cost_t{});
   // Setup costs table
-  node_cost_t costs{{"a", 6},{"b", 2},{"finish", max}};
+  node_cost_t costs{{"a", 6},{"b", 2},{"finish", std::numeric_limits<unsigned>::max()}};
   // Setup parents table
   parent_graph_t parents{{"a", "start"}, {"b", "start"}};
+
+  // A vector of processed nodes
+  std::vector<node_t> processed;
+  processed.reserve(3U);
+  // A lambda function to find the lowest cost node
+  const auto find_lowest_cost_node = [&processed](const node_cost_t& costs)
+	                             {
+                                       auto lowest_cost = std::numeric_limits<unsigned>::max();
+                                       node_t lowest_cost_node{};
+                                       // Go through each node in the costs graph
+                                       for (const auto& nodeCost : costs)
+                                       {
+                                         const auto& cost = nodeCost.second;
+                                         const auto& node = nodeCost.first;
+                                         // Check if this node is processed or not;
+                                         bool isNotProcessed = std::find(processed.cbegin(), processed.cend(), node) == processed.cend();
+                                         // Find the lowest cost node
+                                         if (cost < lowest_cost && isNotProcessed)
+                                         {
+                                           lowest_cost = cost;
+                                           lowest_cost_node = node;
+                                         }
+                                       }
+                                       return lowest_cost_node; 
+				     };
+
   // node is "b" at this time
   auto node = find_lowest_cost_node(costs);
   while (!node.empty())
@@ -72,8 +72,10 @@ int main(void)
     node = find_lowest_cost_node(costs);
   }
   std::cout << "Cost from the start to each node:" << std::endl;
-  std::for_each(costs.cbegin(),
-                costs.cend(),
-                [](const std::pair<node_t, unsigned>& cost) { std::cout << cost.first << " " << cost.second << std::endl; });
+  // prints finish 6 b 2 a 5
+  for (const auto& cost : costs)
+  {
+    std::cout << cost.first << " " << cost.second << std::endl;
+  } 
   return 0;
 }