Finding number of nodes along a path - c++

Question

I am trying to navigate through a ghetto map. I'm inputting my nodes from a .txt that has values like this:
3 -1
2 3 -1
1 -1
0 1 4 6 -1
3 5 7 -1
4 7 8 -1
3 7 -1
4 5 6 8 -1
5 7 -1
10 -1
9 -1
So:
node 0 will be connected to node 3
node 1 will be connected to nodes 2 and 3
node 2 will be connected to node 1
and so on... the '-1' is just to terminate the line
Currently, I am storing them in an array of size 11, where I've just used getline() to pull each line number into the matching array cell; this is to output to the screen. I will also put them into a 2d array where each value had its own cell. I'm going to ask the user for a starting node, and ending node, then I'll use a recursive function to calculate a path between the two (if there is one), and output how many nodes are along that path. I'm not even interested in the optimal path, any will do.
How would I go about this recursively?
The unfinished code thus far:
#include<iostream>
#include<fstream>
#include<string>
using namespace std;
const int ARRAY_SIZE = 11;
void toString(string network[ARRAY_SIZE]);
int numNodes(string network[], int start, int end);
int main()
{
int start;
int end;
// inputting network into array
string network[ARRAY_SIZE];
ifstream in;
in.open("network.txt");
if (in.is_open())
{
while (!in.eof())
{
for (int i = 0; i < ARRAY_SIZE; i++)
{
getline(in, network[i]);
}
}
}
in.close();
//start of user prompts
cout << "Welcome. " << endl << "Here is the network " << endl << endl;
toString(network);
// the loop for start val
do
{
cout << "Please enter a a starting node number (0-10), enter '-1' to quit" << endl;
cin >> start;
if (start == -1)
return 0;
} while (start < 0 && start > 10);
toString(network);
//loop for end value
do
{
cout << "Please enter an ending node number (0-10), enter '-1' to quit" << endl;
cin >> end;
if (start == -1)
return 0;
} while (end < 0 && end > 10);
//recursive stuffs
return 0;
}
int numNodes(string network[], int start, int end)
{
//unfinished function
int num;
//base case
if (start == end)
{
return 1;
}
//recursion
else
{
}
return num;
}
void toString(string network[ARRAY_SIZE])
{
cout << endl;
for (int i = 0; i < ARRAY_SIZE; i++)
{
cout << network[i] << endl;
}
cout << endl;
}

Answer 1

Not sure what you mean by 'ghetto map', I'm guessing you its just a joke.
What you are actually talking about is a concept in Computer Science/Discrete Mathematics called a Graph. There are many types of graphs, graphs that have only positive weights graphs that contain negative weights, graphs in which all paths are bidirectional, graphs which paths are uni directional graphs where edges must all be connected, graphs were edges have a certain wight, capacity and/or some other feature etc...
In this case what I think what you are dealing with is an unweighted (no weights assigned to edges) directed (a connection from A to B does not imply a connection from B to A) graph (unweighted directed graph) and where the graph may additional be unconnected or not.
You are additionally using a type of Adjacency List in order to represent the connections between graph nodes.
There are many algorithms to traverse a graph (such as Dijkstras for path finding or Uniform Cost Search), however most if not all these algorithms come from two basic search algorithms called Depth First Search and Breadth First Search
Depth first search is exactly what the name implies. If you have some structure to represent your graph (say, your adjacency list) you will continually search the right or left most node to the deepest point until you either hit your goal or a dead end. This might look like the following (note this is Python):
def DepthFirstSearch(adjacencylist, start, end):
traversallist = []
traversallist.push(start)
for edge in adjacencylist[start]:
if edge.connectsTo(end):
traversalstack.push(end)
return traversallist
else:
resursivelist = DepthFirstSearch(adjacencylist, edge.endNode(), end)
if resursive_list != []:
return traversallist.extend(recursivelist)
return []
if it returns an empty list ([]) there was no connection. If it didn't there was a connection and returned the first path found.
Breadth frist search is exaclty what its name implies. In the same scenario as before, instead of searching for the deepest node you search along each connecting edge first before going deeper. This might look like the following:
#note that queue starts with the start element
def BreadthFirstSearch(adjacencylist, queue, end):
start = queue.pop()
traversallist = []
traversallist.push(start)
for edge in adjacencylist[start]:
if edge.connectsTo(end):
traversalstack.push(end)
return traversallist
queue.push(adjacencylist[start])
if not queue.empty():
return traversallist.extend(BreadthFirstSearch(adjacencylist, queue, end))
else:
return []
Both of these methods, however, will run infinently in the case where you have a loop during traversal. To avoid this, you can setup a list (or for bettern runtime complexity, a hashtable) to see if you've already traversed something.
def DepthFirstSearch(adjacencylist, start, end, closedset):
...
if start not in closedset:
...
else:
return []
def BreadthFirstSearch(adjacencylist, queue, end, closedset):
...
if start not in closedset:
...
else:
return []
This should give you enough information to implement a graph path finder that will return a path (of which you can simply return the size of if you only need the number of nodes) in c++.