C++ 深度优先搜索的替代算法

一个问题涉及在有向图中进行深度优先搜索，以找到从特定节点可以到达的所有节点。下面给出的解决方案在codechef上给出了错误的结果。但是我找不到任何测试用例，对于这些测试用例，这可能会产生与常规DFS算法不同的结果

我知道我可以直接实现正确的算法来得到正确的结果，但我想知道为什么我的解决方案是不正确的，这样我以后就不会重复了。请帮助我确定此解决方案的问题所在。代码被注释以解释我的方法

#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

typedef long long int lli;
vector <lli> g[1000+5]; // the adjacency list 1 indexed
void dfs(lli j, lli i);

int main(){
    lli n, m, k, a, b;
    // n = number of nodes
    // m = number of relations
    // k = multiplication factor
    cin >> n >> m >> k;
    while(m--){
        // a,b means a is dependent upon b (directed graph)
        cin >> a >> b;
        g[a].push_back(b);
    }

    for(lli j = 1; j <= n; j++)
    for(lli i = 0; i < g[j].size(); i++){
        dfs(j, g[j][i]); // adds dependencies of g[j][i] 
                         // to adjacency list of j
    }

    // ans is the minimum no of nodes dependent on a particular node
    lli ans = g[1].size();
    for(lli i = 1; i <= n; i++){
        if(g[i].size() < ans)
        ans = g[i].size();
    }

    cout << (ans+1)*k <<"\n";
}

void dfs(lli j, lli i){
    // adding dependencies of a node to itself 
    // would result in an infinite loop?
    if(i != j){
        for(lli k = 0; k < g[i].size(); k++){
            // a node is not dependent on itself
            if(g[i][k]!=j && find(g[j].begin(), g[j].end(), g[i][k])==g[j].end()){
            g[j].push_back(g[i][k]);
            dfs(j, g[i][k]);
            }
        }       
    }
}`

#包括
#包括

链接以获得正确的解决方案：
您的问题是，您没有意识到在给定的问题约束条件下可能存在多条边，否则它看起来是正确的。看看这个测试用例：

2 4 1
1 2
1 2
2 1
2 1

您的程序将返回3，但只有2个顶点

话虽如此，我想补充一点，我不同意示例解决方案：它说运行时间是
O（N^2）
，这是不正确的，因为它启动
N
dfs，每个dfs的成本是
O（N+M）
，从而导致
O（N*（N+M））
对于
N=10^3
和
M=10^6
在0.01秒的时间限制内没有变化

实际上，这个问题可以通过使用检测强连接组件的算法在
O（N+M）
中解决。
同意。这属于代码审查。只有当代码实际工作正常时，它才属于代码审查。您是否从法官那里得到“错误结果”或“超出时间限制”？请将带有硬编码输入的代码发布到您的程序中。看到所有这些“在线法官”帖子会让人感到很累，而发布的代码中包含类似这样的语句（
cin>>n>>m>>k；
）。只需将n、m和k初始化为再现错误的值。