Question

给定具有N个节点和N-1个边缘的未加权和无向树，我需要找到源S和目标D之间的最小距离。

代码：

vector<vector<int> >G(110);

bool check(int node,vector<int>path)
{
    for(int i=0;i<path.size();++i)
    {
        if(path[i]==node)
           return false;
    }
    return true;
}
int findMinpath(int source,int target,int totalnode,int totaledge)
{
    vector<int>path;
    path.push_back(source);
    queue<vector<int> >q;
    q.push(path);
    while(!q.empty())
    {
        path=q.front();
        q.pop();
        int lastNode=path[path.size()-1];
        if(lastNode==target)
        {
            return path.size()-1;
        }
        for(int i=0;i<G[lastNode].size();++i){
            if(check(G[lastNode][i],path)){
                vector<int>new_path(path.begin(),path.end());
                new_path.push_back(G[lastNode][i]);
                q.push(new_path);
         }}}
    return 1;
}

然后在主要：

int N,S,E;
cin>>N>>S>>E;
for(int i=1;i<=N-1;++i)
{
    int u,v;
    cin>>u>>v;
    G[u].push_back(v);
    G[v].push_back(u);
 }
 cout<<findpaths(S,E,N,N-1)<<"\n";

可以进一步优化，因为我只需要S和E之间的最小距离

Answer 1

您似乎正在向您的队列推送向量，每个向量包含到目前为止的实际路径。但是你只能推动节点，因为你只使用那些向量中的最后一个节点，而是存储距离源的每个节点的距离。

这会快得多，因为你不会在每一步都复制矢量。

跟踪阵列中的距离，并使用它们确保您不会多次访问节点。

未经测试，但应该明白：

int distance[110 + 1]; // d[i] = distance from source to i, initialize with a large number

int findMinpath(int source,int target,int totalnode,int totaledge)
{
    for (int i = 0; i <= totalnode; ++i)
    {
        distance[i] = 2000000000;
    }

    queue<int> q;
    q.push(source);
    distance[source] = 0;
    while(!q.empty())
    {
        node=q.front();
        q.pop();
        if(node==target)
        {
            return distance[node];
        }
        for(int i=0;i<G[node].size();++i){
            if(distance[node] + 1 < distance[ G[node][i] ]){
                distance[ G[node][i] ] = distance[node] + 1
                q.push(G[node][i]);
         }}}
    return 1;
}

树中两个节点之间的最小距离

1 个答案: