lostecho/grokking_algorithms
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Use lambda function

Browse Source
This commit is contained in:
fhl43211
2020-02-21 09:06:58 -08:00
parent 4fd96f6987
commit e6558351a8
1 changed files with 34 additions and 32 deletions
Download Patch File Download Diff File Expand all files Collapse all files

66
07_dijkstras_algorithm/c++11/01_dijkstras_algorithm.cpp
View File

@@ -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;
}