Question

问题涉及在有向图中进行深度优先搜索，以找到可从特定节点到达的所有节点。下面给出的解决方案在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]);
            }
        }       
    }
}`

问题的链接：problem

正确解决方案的链接：correct solution

Answer 1

您的问题是您不了解给定问题约束可能出现的多边缘，否则它看起来是正确的。看看这个测试用例：

var newPostKey = firebase.database().ref().push().key;

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

话虽如此，我想补充一点，我不同意示例解决方案：它表示运行时间为2 4 1 1 2 1 2 2 1 2 1这不是真的，因为它每个都启动O(N^2) dfs费用N因此导致O(N+M) O(N*(N+M))和N=10^3的时间限制为0.01秒没有变化！

实际上，这个问题可以在M=10^6中使用算法检测强连通分量来解决。

深度优先搜索的替代算法

1 个答案: