efficient loop of a map within a map c++ - loops

Question

I am attempting to find an efficient loop over a map data structure.
The map structure maps the following integers:
1 2, 2 3, 3 1, 4 1, 4 5, 5 3, 5 6, 5 7, 5 8, 6 4, 7 6, 8 9, 9 10
The resulting map looks as follows:
1| 2
2| 3
3| 1
4| 1 5
5| 3 6 7 8
6| 4
7| 6
8| 9
9| 10
Start : 4
Result :
1(1) 2(2) 5(1) 3(2) 6(2) 7(2) 8(2)
Can anybody suggest how to efficiently loop (possibly recursive method) so that, given a start of say 4, the result would be
1(1), 2(2), 5(1), 3(2), 6(2), 7(2), 8(2), 9(3), 10(4)
So the idea is to use each inner key, as an outer key, starting with a given outer key. With outer 4 for example, the inner keys are 5 and 1. So use 5 and 1 as outer keys to obtain inner keys (3 6 7 8) and (2), the process should continue mapping the inner keys to outer keys. A running total should be kept per "jump". So it probably resolves to a recursive problem rather than a loop.
The process should stop if either you reach the starting point, 4 in the above scenario, or there are no more inner keys, for example, 10 has no mapping.
The loop starting at line 44, only performs the above, up to two levels, which is inadequate.
#include <iostream>
#include <map>
#include <sstream>
int digit_count(int number) {
int digits = 0;
if (number < 0) digits = 1; // remove this line if '-' counts as a digit
while (number) {
number /= 10;
digits++;
}
return digits;
}
int main() {
int v1, v2;
std::map< int, std::map< int, int> > m;
std::istringstream stm {"1 2 2 3 3 1 4 1 4 5 5 3 5 6 5 7 5 8 6 4 7 6 8 9 9 10"};
while (stm >> v1 >> v2) {
m[v1];
m[v1][v2] = 1;
}
std::cout << "Map layout " << "\n";
std::string ss = "";
int dc = digit_count(m.rbegin()->first); // equals max number
for (const auto & p : m) {
std::cout << p.first << ss.append(" ", (dc - digit_count(p.first))) << "| ";
for (const auto & val : p.second)
std::cout << val.first << " ";
ss = "";
std::cout << "\n";
}
int start {4};
std::cout << "\nStart : " << start << "\n";
std::cout << "Result : " << "\n";
// efficient loop
for (const auto & e : m[start]) {
std::cout << e.first << "(" << e.second << ") ";
for (const auto & x : m[e.first])
std::cout << x.first << "(" << (e.second + x.second) << ") ";
}
std::cout << "\n";
return 0;
}
Any help would be much appreciated.

Answer 1

Took me a while, but I've answered my own question, and thought I'd update the post. The only way I could think of finding a solution was to create a recursive function. I don't think it is possible to achieve with loops. I didn't select Dijkstra's algorithm, since there are no weights to consider and the results of this recursive function serve as input to a red black tree where each node of the red black tree holds a hash table (unordered_map).
So the result of the query on the combined red black tree/hash table is Log n, to find the shortest path. The problem is providing the input, as you can see from below, is recursive and inefficient.
#include <iostream>
#include <map>
#include <sstream>
#include <set>
#include <vector>
#include <fstream>
int digit_count(int number) {
int digits = 0;
if (number < 0) digits = 1; // remove this line if '-' counts as a digit
while (number) {
number /= 10;
digits++;
}
return digits;
}
struct vertex {
int point;
mutable bool visited{false};
int id;
};
void clear_visited(std::map<int, vertex>& verteces) {
for (const auto & e : verteces) {
e.second.visited = false;
}
}
void traverse_graph(std::map<int, vertex>& verteces, const vertex & v, std::map< vertex, std::map< vertex, int> >& graph, int& counter) {
if (verteces[v.id].visited)
return;
++counter;
verteces[v.id].visited = true;
std::cout << v.point << "(" << counter << ") ";
for (const auto & e : graph[v]) {
traverse_graph(verteces, e.first, graph, counter);
}
}
void start_traverse_graph(std::map<int, vertex>& verteces, const vertex & v, std::map< vertex, std::map< vertex, int> >& graph) {
if (verteces[v.id].visited)
return;
verteces[v.id].visited = true;
for (const auto & e : graph[v]) {
int counter{0};
clear_visited(verteces);
verteces[v.id].visited = true;
traverse_graph(verteces, e.first, graph, counter);
}
}
bool operator<(vertex a, vertex b) { return a.point < b.point; }
int main (int argc, char *argv[]) {
vertex v1, v2;
std::map< vertex, std::map< vertex, int> > m;
std::istringstream stm {"1 2 2 3 3 1 4 1 4 5 5 3 5 6 5 7 5 8 6 4 7 6 8 9 9 10"};
std::set<vertex> vertecesSet;
std::map<int, vertex> verteces;
while (stm >> v1.point >> v2.point) {
v1.id = v1.point;
v2.id = v2.point;
m[v1];
m[v1][v2] = 1;
vertecesSet.insert({v1.point, false, v1.point});
vertecesSet.insert({v2.point, false, v2.point});
}
for(auto & el : vertecesSet)
verteces[el.id] = std::move(el); // dont need set objects anymore so move them
std::cout << "Map layout " << "\n";
std::string ss = "";
int dc = digit_count(m.rbegin()->first.point); // equals max number
for (const auto & p : m) {
std::cout << p.first.point << ss.append(" ", (dc - digit_count(p.first.point))) << "| ";
for (const auto & val : p.second)
std::cout << val.first.point << " ";
ss = "";
std::cout << "\n";
}
vertex start {5,false,5};
std::cout << "\nStart : " << start.point << "\n";
start_traverse_graph( verteces, start, m);
std::cout << "\n";
return 0;
}