spfa+位运算 2017.10.9 t3

这里写图片描述

#include<iostream>
#include<cstdio>
#include<queue>
#define Maxn (1<<20)+200005
#define Maxm 400001
using namespace std;
int n,m,to[Maxn],nxt[Maxn],head[Maxn],e,val[Maxn],a[Maxm],x,y,dis[Maxn];
bool use[Maxm];
void add(int x,int y,int z)
{
    e++;
    to[e]=y;
    nxt[e]=head[x];
    head[x]=e;
    val[e]=z;
}
int main()
{
    freopen("1.txt","r",stdin);
//  freopen("3.txt","w",stdout);
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&a[i]);
        add(i,a[i]+n,1);add(a[i]+n,i,0);
    }
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d",&x,&y);
        add(x,y,1);
    }
    for(int i=1;i<=(1<<20)+n;i++)
    {
        if(i!=1) dis[i]=1e8; 
    }
    queue<int>q;
    q.push(1);
    use[1]=1;
    while(!q.empty())
    {
        int pc=q.front();
        q.pop();use[pc]=0;
        for(int i=head[pc];i;i=nxt[i])
        {
            if(dis[to[i]]>dis[pc]+val[i])
            {
                dis[to[i]]=dis[pc]+val[i];
                if(!use[to[i]])
                {
                    use[to[i]]=1;
                    q.push(to[i]);
                }
            }
        }
        if(pc>n)
        {
            pc-=n;
            for(int k=0;(1<<k)<=pc;k++)
            {
                if((pc&(1<<k))&&((1<<k)<pc))
                {
                    int v=pc^((1<<k)+n);//按位依次亦或求出可能的val[j]值并连边
                    if(dis[v]>dis[pc+n])
                    {
                        dis[v]=dis[pc+n];
                        if(!use[v])
                        {
                            use[v]=1;
                            q.push(v);
                        }
                    }
                }
            }
        }
    }
    for(int i=1;i<=n;i++)
    {
        if(dis[i]==1e8) printf("-1\n");
        else printf("%d\n",dis[i]);
    }
}
**SPFA + 堆优化通常没有实际好处,反而可能更慢或出错**。下面我们详细解释为什么。 --- ### 一、SPFA 本身是什么? SPFA(Shortest Path Faster Algorithm)是 **Bellman-Ford 算法的队列优化版本**,核心思想是: - 只有当某个节点的最短距离被更新了,才用它去松弛其邻接点。 - 使用一个普通队列(FIFO)来维护待处理的节点。 ```python from collections import deque def spfa(n, graph, start): dist = [float(&#39;inf&#39;)] * 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 的优势就在于灵活地处理负权边,而堆会限制这种灵活性 ---
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值