Question

我似乎并不理解Wikipedia's paragraph为什么Dijkstra最短路径问题是O((|E|+|V|)*log(|V|))

假设我使用二进制堆，提取所有顶点将需要V * logV，E * logV项来自何处？

请有人开导我吗？

Answer 1

当您从堆中提取顶点时，您需要检查来自该节点的所有边并对每个邻居执行一些处理（减少键）。

这意味着我们最终会在整个算法中检查所有边缘，并且每个边缘可能需要O（logV），因此总共O（ElogV）除了O（VlogV）成本以从中移除最小条目每个顶点的堆。

Answer 2

在Dijstra算法中，基本上你可以将所有可用的顶点作为一个选项加入，你可以选择最少的顶点。基本上如果你一步一步走。

节点：仅源：边：直接边缘来自源。

添加每个边缘将占用log（Edge_taken_in）时间尽量少用它们并删除它。

添加刚刚发现的节点的所有边缘，添加到达该节点的成本，并将它们全部添加到我们的堆或任何O（log（n））工作数据结构中并重复。

好了，现在这些步骤将继续进行，直到发现每个顶点。

对于每个顶点，您将添加所有顶点（最大值可以是O（V）（如果节点连接到所有其他节点）。）
删除一个最小值并重新制作堆/（以及DS u using）。

好的，我们得到两件事要处理。

第一次O（V）插入V次给出

O((V^2)log(V))

（你可以说V ^ 2（log（E））

但这与

log (E) = log(V^2) = O(log(V))).

现在第二步将通过以最低成本提取边缘来获得每个节点的V次。

因此

T = O( (V^2)log(V) + (V)O(log(V)))

现在E = O（V ^ 2） Sp我们可以说。

T=O((E+V) log(V)).

这是代码

#include<iostream>
#include<vector>
#include<utility>
#include<limits.h>
#include<queue>
using namespace std;
class compare{
public:
  bool operator()(pair<int ,int> p,pair<int ,int> q)
  {
    if(p.first<q.first)
      return false;
    else
      return true;
  }
};
int main()
{
  int count,min,mini,n,m,i,x,y,d,s;
  cin>>n>>m;
  int a[n];
  bool b[n];
  priority_queue<pair<int ,int>,vector<pair<int , int> >,compare>pq; 
  pair<int ,int>p;
  vector<pair<int ,int > >V[n];
  for(i=0;i<m;++i)
    {
      cin>>x>>y>>d;
      //  x--;y--;
      p.first=y;
      p.second=d;
      V[x].push_back(p);
      p.first=x;
      V[y].push_back(p);
    }
  while(1)
    {
      cout<<"Enter the Source\t";
      cin>>s;
      for(i=0;i<n;++i)
    {
      a[i]=INT_MAX;
      b[i]=false;
    }
      count=1;
      a[s]=0;
      p=make_pair(a[s],s);
      pq.push(p);
      // s--;
      min=0;
      while(!pq.empty() && pq.top().first!=INT_MAX)
    {
      p=pq.top();
      pq.pop();
      cout<<p.first<<" "<<p.second<<endl;
      if(b[p.second]==true)
        {
          continue;
        }
      else
        {
          //in v second is distance and first is index
          mini=p.second;
          for(i=0;i<V[mini].size();++i)
        {
          cout<<i<<" "<<V[mini][i].first<<" "<<a[V[mini][i].first]<<" "<<a[mini]+V[mini][i].second<<endl;
          if(b[V[mini][i].first]==false&&a[V[mini][i].first]>a[mini]+V[mini][i].second)
            {
              a[V[mini][i].first]=a[mini]+V[mini][i].second;
              p=make_pair(a[V[mini][i].first],V[mini][i].first);

              cout<<" *"<<p.first<<" "<<p.second<<endl;
              pq.push(p);
            }
        }
          b[mini]=true;
        }
      cout<<endl<<endl;
    }

      for(i=0;i<n;++i)
    cout<<a[i]<<" ";
      cout<<endl;


    }
  return 0;
}

Dijkstra最短路径的复杂性

2 个答案: