Algorithm Dijkstra最短路径的复杂性

我似乎不明白为什么Dijkstra最短路径问题是

O（| E |+| V |）*log（| V |）

假设我使用了一个二进制堆，提取所有顶点需要V*logV，E*logV术语从何而来

---

有人能告诉我吗？

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

---

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

在Dijstra算法中，基本上是将u可用的所有顶点添加为一个选项，然后取最小值。基本上，如果你一步一步地走

节点：仅源：边：来自源的直接边

添加每个边需要日志（边已占用）时间 取最少的一个，去掉那个

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

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

对于每个顶点，您将添加所有超出它的边（最大值可能是O（V）（如果节点连接到所有其他节点））

删除一个最小值并使用重新生成堆/（和DS u）

好的，我们有两件事要处理

第一个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） 我们可以说

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;
}

#包括
#包括
#包括
#包括
#包括
使用名称空间std；
班级比较{
公众：
布尔运算符（）（对p，对q）
{
如果（p.first>n>>m；
int a[n]；
布尔b[n]；
优先权；
pairp；
向量v[n]；
对于（i=0；i>x>>y>>d；
//x--；y--；
p、 第一个=y；
p、 秒=d；
V[x]。推回（p）；
p、 第一个=x；
V[y]。推回（p）；
}
而(1)
{
沙发；
对于（i=0；i