DFS traversal and cycle in directed graph - c++

Question

I have a directed graph. Initially, all nodes are assumed to be unvisited and flag is -1 in vector<int>flag. Now we start from a source node & push into stack<int>s and make flag[source]=0 . Now I do DFS traversal & push nodes if(flag[node]==-1)& make flag[node]=0. if all the DFS directed links are visited I pop the element of the stack and mark it flag[s.top()]=1; while pushing if we encounter a node with flag[nodes]==0, the cycle is detected and i do an increment in int final variable;`
you can see in my code, I am storing DFS traversal in a temp vector, which I think is garbage, how can I directly pass these connected nodes directly to check the flag and detect the cycle. currently my code works but fails for larger input. kindly looking for help.
#include<iostream>
#include<vector>
#include<stack>
#include<map>
using namespace std;
int mx=1e5+5;
vector<bool>vist(mx);
vector<vector<int>>Graph(mx);
void dfs(int node,vector<int>&dfs_vec){
vist[node]=true;
dfs_vec.push_back(node);
for(int neigh: Graph[node]){
if(!vist[neigh]){
dfs(neigh,dfs_vec);
}
}
}
//my temp vector is in while loop of main.
int main(){
int num_vertex;int num_edge;
cin>>num_vertex>>num_edge;
int u,v;
for(int i=0;i<num_edge;i++){
cin>>u>>v;
Graph[u].push_back(v);
}
vector<int>flag(num_vertex+1,-1);
stack<int>s;
int source=1;
s.push(source);
flag[source]=0;
int final=0;
while(!s.empty()){
int x=s.top();
vector<int>temp;
dfs(Graph[x][0],temp);
for(auto y:temp){
if(flag[y]==-1){
s.push(y);
flag[y]=0;
}
else if(flag[y]==0){
final++;
}
}
flag[s.top()]=1;
s.pop();
vist.clear();
vist.resize(mx);
}
if(final>0){
std::cout<<"Graph is cyclic";
}
else{
std::cout<<"Graph is not cyclic";
}
}

Answer 1

It is important to minimize the parameters in the signature of a recursive function if you want to handle large datasets. Each call requires the parameters to be kept on the stack, a fairly limited resource.
To minimize the parameters, use a method on a class which stores just one copy of the parameter data as an attribute whenever possible. For DFS, everything except the index of the currently visited node can be moved out of the parameter list.
Here is a straight forward implementation of DFS which I have used successfully on graphs containing hundreds of thousands of vertices.
void cPathFinder::depthRecurse(
int v )
{
visitor(v);
// remember this node has been visited
myPath[v] = 1;
// look for new adjacent nodes
for (int w : adjacent(v))
if (!myPath[w])
{
// search from new node
depthRecurse(w, visitor);
}
}
FYI here is brief discussion of some of the issues to think about when designing a class to implement graph theory algorithms. https://github.com/JamesBremner/PathFinder2/wiki/cGraph-Class-Design