spfa dijkstra队列优化

最新推荐文章于 2024-04-18 16:50:37 发布

原创最新推荐文章于 2024-04-18 16:50:37 发布 · 428 阅读

0 ·

CC 4.0 BY-SA版权

图论模板专栏收录该内容

5 篇文章

订阅专栏

本文详细介绍了两种经典的最短路径算法：SPFA（Shortest Path Faster Algorithm）和Dijkstra算法。通过C++代码实现展示了如何使用这两种算法来解决单源最短路径问题，并解释了关键的数据结构和步骤。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

#define INF 0x3f3f3f  
#define maxn 110//点数   
#define maxm 10010//边数   
using namespace std;  
int dis[maxn];//储存起点到当前点的最短路   
int visit[maxn];//标记当前点是否在队列中   
int head[maxn];  
int n,top;  

struct node  
{  
    int to,val,next;  
}edge[maxm];  

void add(int a,int b,int c)//建立邻接表   
{  
    edge[top].to=b;  
    edge[top].val=c;  
    edge[top].next=head[a];//指向上一个，edge[].next指向的是前一个，相当于链表里的指针的作用     
    head[a]=top++;  
}  

void spfa(int start)  
{  
    int i,j,next,u,v;  
    queue<int>q;  
    for(i=1;i<=n;++i)  
       dis[i]=INF;  
    dis[start]=0;  
    visit[start]=1;  
    q.push(start);  
    while(!q.empty())  
    {  
        u=q.front();  
        q.pop();  
        visit[u]=0;//消除标记   
        for(i=head[u];i!=-1;i=edge[i].next)//遍历以u为前点的所有边   
        {  
            v=edge[i].to;  
            if(dis[v]>dis[u]+edge[i].val)  
            {  
                dis[v]=dis[u]+edge[i].val;  
                if(!visit[v])  
                {  
                    visit[v]=1;  
                    q.push(v);  
                }  
            }  
        }  
    }  
    printf("%d\n",dis[n]);  
}

#define pa pair<int,int>
struct node {
    int to, next, v;
};
const int N = 2E6 + 10;
const int INF = 0x7fffffff
node edge[N];
int cnt, head[N], n, dis[N];
void add(int u,int v,int w) {
    cnt++;
    edge[cnt].to=v;
    edge[cnt].next=head[u];
    head[u]=cnt;
    edge[cnt].v=w;
}

void dijkstra(int s) {
    priority_queue<pa,vector<pa>,greater<pa> >q;
    int i, now;

    for (i = 1; i <= n; i++)
        dis[i] = INF;
    dis[s] = 0;
    q.push(make_pair(0,s));
    while (!q.empty()) {
        now = q.top().second;
        q.pop();
        for (i = head[now]; i != -1; i = edge[i].next){
            if (dis[now] + edge[i].v < dis[edge[i].to]) {
                dis[edge[i].to] = dis[now] + edge[i].v;
                q.push(make_pair(dis[edge[i].to], edge[i].to));
            }   
        }

    }
}
int main() {

    memset(head, -1, sizeof(head));
    cnt = 0;

}