spfa的SLF 和 LLL优化算法

最新推荐文章于 2024-09-29 14:23:24 发布
原创 最新推荐文章于 2024-09-29 14:23:24 发布 · 2.2k 阅读 · 5 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#SPFA #LLL优化 #SLF优化 #双向队列优化 #优化

   一. spfa的SLF优化，就是双向队列优化，在spfa压入队列时，判断要压入队首还是队尾。这个优化可以优化15%~20%。

   二. spfa的LLL优化，就是记录现在队列中元素所代表值的平均值，和要压入元素的值相比较，如果大于平均值，直接压入对列尾部，LLL优化+SLF优化可以优化大概50%。

  我们以一道判负环的题为例子，来讲解一下。


Wormholes
Time Limit: 2000MS Memory Limit: 65536K
Total Submissions: 53294 Accepted: 19856

Description

While exploring his many farms, Farmer John has discovered a number of amazing wormholes. A wormhole is very peculiar because it is a one-way path that delivers you to its destination at a time that is BEFORE you entered the wormhole! Each of FJ's farms comprises N (1 ≤ N ≤ 500) fields conveniently numbered 1..N, M (1 ≤ M ≤ 2500) paths, and W (1 ≤ W ≤ 200) wormholes.

As FJ is an avid time-traveling fan, he wants to do the following: start at some field, travel through some paths and wormholes, and return to the starting field a time before his initial departure. Perhaps he will be able to meet himself :) .

To help FJ find out whether this is possible or not, he will supply you with complete maps to F (1 ≤ F ≤ 5) of his farms. No paths will take longer than 10,000 seconds to travel and no wormhole can bring FJ back in time by more than 10,000 seconds.

Input

Line 1: A single integer,  F.  F farm descriptions follow. 
Line 1 of each farm: Three space-separated integers respectively:  N,  M, and  W 
Lines 2.. M+1 of each farm: Three space-separated numbers ( S,  E,  T) that describe, respectively: a bidirectional path between  S and  E that requires  T seconds to traverse. Two fields might be connected by more than one path. 
Lines  M+2.. M+ W+1 of each farm: Three space-separated numbers ( S,  E,  T) that describe, respectively: A one way path from  S to  E that also moves the traveler back  T seconds.

Output

Lines 1.. F: For each farm, output "YES" if FJ can achieve his goal, otherwise output "NO" (do not include the quotes).

Sample Input

2
3 3 1
1 2 2
1 3 4
2 3 1
3 1 3
3 2 1
1 2 3
2 3 4
3 1 8

Sample Output

NO
YES

Hint

For farm 1, FJ cannot travel back in time. 
For farm 2, FJ could travel back in time by the cycle 1->2->3->1, arriving back at his starting location 1 second before he leaves. He could start from anywhere on the cycle to accomplish this.

Source

USACO 2006 December Gold

首先 ：我们用的是普通spfa。跑完程序是141ms 

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<queue>
using namespace std;
#define inf 0x3f3f3f3f
struct s1{
   int to;
   int val;
   int next;
}a[10000];
int head[10000];
int dis[10000];
int book[10000];
int cnt;
void add(int u,int v,int w)
{
    a[++cnt].to=v;
    a[cnt].val=w;
    a[cnt].next=head[u];
    head[u]=cnt;
}
int main()
{
    int F;
    scanf("%d",&F);
    while(F--)
    {
        int n,m,w;
        cnt=0;
        scanf("%d%d%d",&n,&m,&w);
        memset(book,0,sizeof(book));
        memset(head,-1,sizeof(head));
        memset(a,0,sizeof(a));
        for(int i=0;i<m;i++)
        {
            int x,y,z;
            scanf("%d%d%d",&x,&y,&z);
            add(x,y,z);
            add(y,x,z);
        }
        for(int i=0;i<w;i++)
        {
            int x,y,z;
            scanf("%d%d%d",&x,&y,&z);
            add(x,y,-z);
        }
        queue<int>q;
        memset(dis,inf,sizeof(dis));
        dis[1]=0;
        book[1]=1;

        q.push(1);
        int cn[10000];
        int flag=0;
        memset(cn,0,sizeof(cn));
        cn[1]=1;
        while(!q.empty())
        {
            int p=q.front();
            q.pop();
            book[p]=0;
            for(int i=head[p];i!=-1;i=a[i].next)
            {
                if(dis[a[i].to]>dis[p]+a[i].val)
                {
                    dis[a[i].to]=dis[p]+a[i].val;
                    if(book[a[i].to]==0)
                    {
                        book[a[i].to]=1;
                        cn[a[i].to]++;
                        if(cn[a[i].to]>=n)
                        {
                            flag=1;
                            break;
                        }
                        q.push(a[i].to);
                    }
                }
            }
            if(flag==1)
                break;
        }
        if(flag==1)
            printf("YES\n");
        else
            printf("NO\n");
    }
}

然后 我们加上 SLF优化 ，跑完程序是94ms。 

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<queue>
using namespace std;
#define inf 0x3f3f3f3f
struct s1{
   int to;
   int val;
   int next;
}a[10000];
int head[10000];
int dis[10000];
int book[10000];
int cnt;
void add(int u,int v,int w)
{
    a[++cnt].to=v;
    a[cnt].val=w;
    a[cnt].next=head[u];
    head[u]=cnt;
}
int main()
{
    int F;
    scanf("%d",&F);
    while(F--)
    {
        int n,m,w;
        cnt=0;
        scanf("%d%d%d",&n,&m,&w);
        memset(book,0,sizeof(book));
        memset(head,-1,sizeof(head));
        memset(a,0,sizeof(a));
        for(int i=0;i<m;i++)
        {
            int x,y,z;
            scanf("%d%d%d",&x,&y,&z);
            add(x,y,z);
            add(y,x,z);
        }
        for(int i=0;i<w;i++)
        {
            int x,y,z;
            scanf("%d%d%d",&x,&y,&z);
            add(x,y,-z);
        }
        deque<int>q;
        memset(dis,inf,sizeof(dis));
        dis[1]=0;
        book[1]=1;

        q.push_back(1);
        int cn[10000];
        int flag=0;
        memset(cn,0,sizeof(cn));
        cn[1]=1;
        while(!q.empty())
        {
            int p=q.front();
            q.pop_front();
            book[p]=0;
            for(int i=head[p];i!=-1;i=a[i].next)
            {
                if(dis[a[i].to]>dis[p]+a[i].val)
                {
                    dis[a[i].to]=dis[p]+a[i].val;
                    if(book[a[i].to]==0)
                    {
                        book[a[i].to]=1;
                        cn[a[i].to]++;
                        if(cn[a[i].to]>=n)
                        {
                            flag=1;
                            break;
                        }
                        if(!q.empty()&&dis[a[i].to]<dis[q.front()])  //判断是要压入队尾还是队首 （SLF优化）
                        {
                            q.push_front(a[i].to);
                        }
                        else
                        {
                            q.push_back(a[i].to);
                        }

                    }
                }
            }
            if(flag==1)
                break;
        }
        if(flag==1)
            printf("YES\n");
        else
            printf("NO\n");
    }
}

最后，我们用SLF加上LLL优化，跑完程序，是47ms。 
#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<queue>
using namespace std;
#define inf 0x3f3f3f3f
struct s1{
   int to;
   int val;
   int next;
}a[10000];
int head[10000];
int dis[10000];
int book[10000];
int cnt;
void add(int u,int v,int w)
{
    a[++cnt].to=v;
    a[cnt].val=w;
    a[cnt].next=head[u];
    head[u]=cnt;
}
int main()
{
    int F;
    scanf("%d",&F);
    while(F--)
    {
        int n,m,w;
        cnt=0;
        scanf("%d%d%d",&n,&m,&w);
        memset(book,0,sizeof(book));
        memset(head,-1,sizeof(head));
        memset(a,0,sizeof(a));
        for(int i=0;i<m;i++)
        {
            int x,y,z;
            scanf("%d%d%d",&x,&y,&z);
            add(x,y,z);
            add(y,x,z);
        }
        for(int i=0;i<w;i++)
        {
            int x,y,z;
            scanf("%d%d%d",&x,&y,&z);
            add(x,y,-z);
        }
        deque<int>q;
        memset(dis,inf,sizeof(dis));
        dis[1]=0;
        book[1]=1;

        q.push_back(1);
        int cn[10000];
        int flag=0;
        memset(cn,0,sizeof(cn));
        cn[1]=1;
        long long sum=0;
        int len=1;
        while(!q.empty())
        {
            int p=q.front();
            q.pop_front();

            if(dis[p]*len>sum)  //LLL优化
            {
                q.push_back(p);
                continue;
            }
            sum-=dis[p];
            book[p]=0;
            len--;
            for(int i=head[p];i!=-1;i=a[i].next)
            {
                if(dis[a[i].to]>dis[p]+a[i].val)
                {
                    dis[a[i].to]=dis[p]+a[i].val;
                    if(book[a[i].to]==0)
                    {
                        book[a[i].to]=1;
                        cn[a[i].to]++;
                        if(cn[a[i].to]>=n)
                        {
                            flag=1;
                            break;
                        }
                        if(!q.empty()&&dis[a[i].to]<dis[q.front()])  //SLF优化
                        {
                            q.push_front(a[i].to);
                        }
                        else
                        {
                            q.push_back(a[i].to);
                        }
                         sum += dis[a[i].to];
                         len++;
                    }
                }
            }
            if(flag==1)
                break;
        }
        if(flag==1)
            printf("YES\n");
        else
            printf("NO\n");
    }
}




【题解】P1186玛丽卡(最短路+图论+SPFA+SLF优化)
水煮皮皮虾
04-08 491
题目描述麦克找了个新女朋友，玛丽卡对他非常恼火并伺机报复。 因为她和他们不住在同一个城市，因此她开始准备她的长途旅行。 在这个国家中每两个城市之间最多只有一条路相通，并且我们知道从一个城市到另一个城市路上所需花费的时间。 麦克在车中无意中听到有一条路正在维修，并且那儿正堵车，但没听清楚到底是哪一条路。无论哪一条路正在维修，从玛丽卡所在的城市都能到达麦克所在的城市。 玛丽卡将只从不堵车的路上通
SPFA的两种优化方法——SLF和LLL
Blogs of zcy1221
05-25 4406
本文将介绍 SPFA(Shortest Path Faster Algorithm) 算法 (Bellman-Ford 算法的队列优化算法的别称) 的两种优化方法：SLF(Small Label First) 优化和LLL(Large Label Last) 优化，并利用实例进行演示.
SPFA的两种优化
C Y
10-05 390
转自：https://blog.youkuaiyun.com/oranges_c/article/details/64124235 这个博客写的比较清楚 SPFA算法有两个优化算法 SLF 和 LLL： SLF：Small Label First 策略，设要加入的节点是j，队首元素为i，若dist(j) &lt; dist(i)，则将j插入队首，否则插入队尾。 LLL：Large Label Last 策略，...
SPFA及SLF优化
weixin_30781107的博客
08-12 184
算法简介SPFA(Shortest Path Faster Algorithm)是Bellman-Ford算法的一种队列实现，减少了不必要的冗余计算。 它可以在O(kE)的时间复杂度内求出源点到其他所有点的最短路径，可以处理负边。 算法流程SPFA对Bellman-Ford算法优化的关键之处在于意识到：只有那些在前一遍松弛中改变了距离估计值的点，才可能引起他们的邻接点的距离估计值的改变。因此，...
spfa SLF优化
wzw-yali的博客
09-25 465
#include #include #include #include #include #include #include using namespace std; typedef long long LL; #define REP(i, a, b) for(register int i = (a), i##_end_ = (b); i <= i##_end_; ++ i) #define
【智能算法】SPFA算法
大雨的博客
09-29 1757
SPFA算法，全称Shortest Path Faster Algorithm，是Bellman-Ford算法的一种队列优化形式，由西南交通大学段凡丁于1994年提出（尽管其证明存在错误，且队列优化的概念在Bellman-Ford算法提出后不久即已存在）。SPFA算法主要用于求解含有负权边的单源最短路径问题，并具备判断负权环的能力。
《经典图论算法》SPFA算法
数据结构和算法
08-01 313
摘要：1，SPFA算法的介绍2，SPFA算法的解题步骤3，SPFA算法的负权回路判断4，SPFA算法的代码实现5，SPFA算法的几种优化方式(SLF，LLL，堆，栈)6，SPFA算法和Dijkstra堆优化的区别1，SPFA算法的介绍SPFA(Shortest Path Faster Algorithm)最短路径快速算法，是求单源点最短路径的，可以有负权边，但不能有负权回路，实际上它是对 Bell...
SPFA 算法和Bellman-Ford 算法与Dijkstra 算法、Floyd 算法有什么异同以及创新性改进或应用
06-03
SPFA算法和Bellman-Ford算法与Dijkstra算法、Floyd算法有以下异同和创新性改进或应用： 异同点： 1. Dijkstra算法、Floyd算法和...4. SPFA算法的改进：SLF算法和LLL算法，对队列的优化方式不同，使得算法更加高效。
spfa算法的优化
最新发布
03-08
### SPFA算法优化方法 SPFA算法（Shortest Path Faster Algorithm）用于解决单源最短路径问题，尤其适合处理带负权边的图。该算法基于队列实现，利用动态逼近法对图进行松弛操作，不断更新节点的最短路径估计值直到...
图论4 详解SPFA
Eric_bells的博客
04-12 673
原理及证明 编辑播报 最短路问题 SPFA算法的全称是：Shortest Path Faster Algorithm，是西南交通大学段凡丁于 1994 年发表的论文中的名字。不过，段凡丁的证明是错误的，且在 Bellman-Ford 算法提出后不久（1957 年）已有队列优化内容，所以国际上不承认 SPFA 算法是段凡丁提出的。 为了避免最坏情况的出现，在正权图上应使用效率更高的Dijkstra算法。 若给定的图存在负权边，类似Dijkstra算法等算法便没有了用武之地，SPFA算法便派上用.
spfa 的 slf 优化
drj
10-23 1149
被战神的 std 虐爆了。。。。。耀爷所谓搞笑 slf 优化，竟然有如此大的作用。 什么是 slf 优化呢？其实就是新扩展的节点在入队时如果其 dis 值小于队首则插入到队首否则插入到队尾。 我也不知道为什么可以有很大的优化，也许令更优的节点先扩展吧。但是效率的对比可能就比较惊人了，一个裸跑 0.8 s 的点竟然跑进了 0.05 s。 Code : bool spfa(int k) {
SPFA算法的四种优化（SLF，LLL，SLF+LLL，DFS）
pursuit的博客
07-30 7426
SPFA算法的四种优化（SLF，LLL，SLF+LLL，DFS）
SPFA，SLF优化
puppywolf的博客
08-16 422
if (dis[xx][yy]<dis[d[head+1][1]][d[head+1][2]]) { t1=d[tail][1]; d[tail][1]=d[head+1][1];
SPFA的SLF优化
m0_73020012的博客
07-02 234
特别鸣谢Dawn-_-cx大佬的讲解。
spfa优化 SLF LLL
弱弱的jxy
12-05 4476
SPFA 是按照 FIFO 的原则更新距离的, 没有考虑到距离标号的作用. 实现中 SPFA 有两个非常著名的优化: SLF 和 LLL. 　　SLF: Small Label First 策略. 　　实现方法是, 设队首元素为 , 队列中要加入节点 , 在 时加到队首而不是队尾, 否则和普通的 SPFA 一样加到队尾. 这可以用个优先级队列维护 　　LLL: La
2017.7.3 SPFA SLF优化
Moon1125666900的博客
07-03 593
SPFA由于玄学复杂度很容易被卡常，SLF优化即在新节点v插入队列时判断，如dis[v]<dis[head]dis[v]<dis[head]插到队首，否则插到队尾。原本3s+的TLE变成50ms的AC…… http://www.gdfzoj.com/oj/contest/144/problems/3 http://paste.ubuntu.com/25010016/
[SPFA的SLF优化] Codeforces Round #257 (Div. 1) B
追
07-21 620
题目链接 ： http://codeforces.com/contest/449/problem/B 题目大意 ： 给定
[spfa][slf优化]道路与航线 AcWing342
Cloth的博客
03-06 463
农夫约翰正在一个新的销售区域对他的牛奶销售方案进行调查。 他想把牛奶送到T个城镇，编号为 1∼T。 这些城镇之间通过R条道路 (编号为1到R) 和P条航线 (编号为1到P) 连接。 每条道路i或者航线i连接城镇Ai到Bi，花费为Ci。 对于道路，0≤Ci≤10,000;然而航线的花费很神奇，花费Ci可能是负数(−10,000≤Ci≤10,000)。 道路是双向的，可以从Ai到Bi，也可以从Bi到Ai，花费都是Ci。 然而航线与之不同，只可...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值