spfa dijkstra堆优化

博客介绍了POJ 2387中涉及的SPFA和Dijkstra(堆优化)算法。SPFA在稀疏图上运行效率高,为O(km)级别,但在稠密图或特殊构造的网格图上可能退化为O(nm);Dijkstra(堆优化)时间复杂度为O(m log n)。

POJ 2387

SPFA

在稀疏图上运行效率较高,为 O(km) 级别,其中k是一个较小的常数。但在稠密图或特殊构造的网格图上,该算法仍可能退化为O(nm)

#include<iostream>
#include<queue>
#include<cstdio>
#define inf 1000000000
using namespace std;
typedef long long ll;
const int N=1010;
int n,m,tot;
int head[1010],ver[4010],edge[4010],Next[4010],d[1010],vis[1010];
void init()
{
    tot=0;
    for(int i=1;i<=n;i++)
        {d[i]=inf;head[i]=0;vis[i]=0;}
    for(int i=1;i<=m*2;i++)
        {ver[i]=0;edge[i]=0;Next[i]=0;}
}
void add(int x,int y,int z)
{
    ver[++tot]=y;edge[tot]=z;Next[tot]=head[x];head[x]=tot;
}
void spfa(int x)
{
    queue<int> q;
    q.push(x);
    d[x]=0;
    vis[x]=1;
    while(!q.empty())
    {
        int x=q.front();
        q.pop();
        vis[x]=0;
        for(int i=head[x];i;i=Next[i])
        {
            int y=ver[i],z=edge[i];
            if(d[y]>d[x]+z)
            {
                d[y]=d[x]+z;
                if(vis[y]==0)
                    {q.push(y);vis[y]=1;}
            }
        }
    }
}
int main()
{
    while(~scanf("%d%d",&m,&n))
    {
        init();
        int x,y,z;
        for(int i=1;i<=m;i++)
        {
            scanf("%d%d%d",&x,&y,&z);
            add(x,y,z);
            add(y,x,z);
        }
        spfa(1);
        printf("%d\n",d[n]);
    }
    return 0;
}

dijkstra (堆优化)

时间 O (m log n )

#include<iostream>
#include<queue>
#include<cstdio>
#define inf 1000000000
using namespace std;
typedef long long ll;
const int N=1010;
int n,m,tot;
int head[1010],ver[4010],edge[4010],Next[4010],d[1010],vis[1010];
void init()
{
    tot=0;
    for(int i=1;i<=n;i++)
        {d[i]=inf;head[i]=0;vis[i]=0;}
    for(int i=1;i<=m*2;i++)
        {ver[i]=0;edge[i]=0;Next[i]=0;}
}
void add(int x,int y,int z)
{
    ver[++tot]=y;edge[tot]=z;Next[tot]=head[x];head[x]=tot;
}
void dijkstra(int x)
{
    priority_queue< pair <int,int> > q;
    d[x]=0;
    q.push(make_pair(-d[x],x));
    while(!q.empty())
    {
        int x=q.top().second;
        q.pop();
        if(vis[x]==1)
            continue;
        vis[x]=1;
        for(int i=head[x];i;i=Next[i])
        {
            int y=ver[i],z=edge[i];
            if(d[y]>d[x]+z)
                {d[y]=d[x]+z;q.push(make_pair(-d[y],y));}
        }
    }
}
int main()
{
    while(~scanf("%d%d",&m,&n))
    {
        init();
        int x,y,z;
        for(int i=1;i<=m;i++)
        {
            scanf("%d%d%d",&x,&y,&z);
            add(x,y,z);
            add(y,x,z);
        }
        dijkstra(1);
        printf("%d\n",d[n]);
    }
    return 0;
}

 

**SPFA + 优化通常没有实际好处,反而可能更慢或出错**。下面我们详细解释为什么。 --- ### 一、SPFA 本身是什么? SPFA(Shortest Path Faster Algorithm)是 **Bellman-Ford 算法的队列优化版本**,核心思想是: - 只有当某个节点的最短距离被更新了,才用它去松弛其邻接点。 - 使用一个普通队列(FIFO)来维护待处理的节点。 ```python from collections import deque def spfa(n, graph, start): dist = [float('inf')] * n in_queue = [False] * n dist[start] = 0 in_queue[start] = True q = deque([start]) while q: u = q.popleft() in_queue[u] = False for v, w in graph[u]: if dist[u] + w < dist[v]: dist[v] = dist[u] + w if not in_queue[v]: q.append(v) in_queue[v] = True return dist ``` ✅ SPFA 的优点: - 能处理负权边 - 平均性能较好(尤其稀疏图) - 实现简单 --- ### 二、能不能加“优化”?比如用优先队列代替普通队列? 你可能会想:“Dijkstra优化更快,那 SPFA 也用试试?” 即:把 `deque` 换成 `heapq`,每次取出当前 `dist` 最小的节点来松弛 —— 这听起来像 Dijkstra! 但问题来了: > ❌ **一旦你用来取最小距离节点,你就不再是 SPFA,也不再是正确的负权最短路算法!** --- ### 三、为什么 SPFA 不适合优化? #### ✅ 正确性问题:优化SPFA 实际上退化为 Dijkstra - Dijkstra 使用的前提是:**边权非负** - 如果你在存在负权边的情况下使用,会出现: - 某个节点虽然当前 `dist` 小,但它之后可能通过负权边变得更小 - 但结构会优先处理“当前小”的点,并可能提前将其弹出,不再更新 - 导致无法正确传播后续的更优路径 → **结果错误** #### ⚠️ 示例说明: ``` A --1--> B --(-2)--> C \ / \--3------------>/ ``` 从 A 出发: - 初始:dist[A]=0, dist[B]=1, dist[C]=3 - 若使用,先处理 B(dist=1),然后更新 C:1 + (-2) = -1 → 更好 - 再处理 C(现在 dist[C]=-1) - 但如果图中有环或更多节点,可能已经忽略了某些本该再次更新的节点 但更大的问题是:**中元素一旦被取出,就不再重新考虑其更优值的可能性**(除非重新入),而频繁入会导致复杂度失控。 --- ### 四、性能分析:优化SPFA 没有收益 | 版本 | 数据结构 | 时间复杂度(平均) | 是否支持负权 | 稳定性 | |------|----------|---------------------|---------------|--------| | SPFA | 队列(deque) | O(kE),k 很小 | ✅ 支持 | 较好 | | SPFA + | 优先队列(heapq) | 接近 O(E log V) | ❌ 在负权下易错 | 差 | | Dijkstra + | 优先队列 | O((V+E) log V) | ❌ 不支持负权 | 稳定 | 👉 结论: - 优化并不能提升 SPFA 的效率 - 反而破坏了 SPFA “允许反复更新”的机制 - 在负权图中可能导致遗漏更优路径 --- ### 五、有没有“带的正确算法”能处理负权? 目前主流算法中: - **没有基于的通用负权最短路算法** - Johnson 算法会在预处理时重赋权,然后用 Dijkstra 多次求解,其中用了,但前提是先消除负权 - 所以的作用是在**非负权子问题**中加速 --- ### 六、总结 ❌ **不要给 SPFA优化!** - ✅ SPFA 应该用普通队列(或双端队列) - ❌ 优化不仅不能提高性能,还可能导致错误结果 - 🚫 它违背了 SPFA 的设计初衷:动态更新和多次入队 - 🔁 SPFA 的优势就在于灵活地处理负权边,而会限制这种灵活性 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值