For loop in recursive function continues after end of recursion - c++

Question

I am implementing a Depth First Search on a graph in C++. Given a starting vertex, the algorithm should perform DFS until a goal node is found (i.e. a node with goal set to true), and return the path taken. I am trying to do this recursively, here is my code:
vector<char>* dfs(graph g, node* s){
static vector<char> path;
s->set_visited();
path.push_back(s->get_tag()); //Adds node to path
if(s->is_goal()){
g.set_all_visited();
}
else{
for(int i=0; i<(s->get_no_edges()); i++){
if(!(s->get_edge(i)->get_dest()->is_visited())) //If it is unvisited, apply recursion
dfs(g, s->get_edge(i)->get_dest());
}
}
return &path;
}
I am aware that the resulting path will just list the nodes in the order they were visited by the DFS, as opposed to an actual path from the start to a goal node.
The problem is that the function continues to print nodes even after a goal node is found. To avoid this, I set all nodes in the graph g to visited using set_all_visited(), and checked in the else part whether a node was visited or not before proceeding, but this does not seem to be working. When I performed dry runs, the function kept on visiting all the edges of a node in the for loop even after a goal node was found, and I do not know how I can stop this from happening.

Answer 1

You're passing g by value instead of by reference. This means that whenever you found a goal node and are coming back from a recursive call, that instance of g still has its nodes set as unvisited. That's why the repetition occurs.

Answer 2

I know your primary question is answered, still I would give few suggestions:
1) Don't use static vector, you can't reuse the function. You can instead create a vector where you're expecting the path and pass pointer to the vector.
2) To make sure you don't have all visited nodes in path, you can return a bool from dfs function to denote if there is a path to destination. You can also avoid passing graph object this way.
With those changes your code will become:
bool dfs(node* s, vector<char>* path){
s->set_visited();
if(s->is_goal()){
path.push_back(s->get_tag());
return true;
}
else{
for(int i=0; i<(s->get_no_edges()); i++){
if(!(s->get_edge(i)->get_dest()->is_visited())) //If it is unvisited, apply recursion
if(dfs(s->get_edge(i)->get_dest(), path)) {
path.push_back(s->get_tag());
return true;
}
}
}
return false;
}
This will return reverse path, ie path from destination to source, there is std::reverse.
If you do a BFS, you'll get shortest path instead of some random path, assuming the edges are of equal weight.