基于各种基础数据结构的SPFA和各种优化

最新推荐文章于 2020-02-13 18:56:58 发布
最新推荐文章于 2020-02-13 18:56:58 发布
阅读量122 收藏
点赞数
文章标签： 数据结构与算法 前端 后端 ViewUI
原文链接：http://www.cnblogs.com/szmssf/p/11047202.html
版权

一、基于各种数据结构的SPFA

以下各个数据均为不卡SPFA的最短路模板：P3371 【模板】单源最短路径（弱化版）的测试时间

1、STL队列：用时: 1106ms / 内存: 8496KB

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<queue>
#include<algorithm>
#define inf 336860180
using namespace std;
int n,m,s,x,y,z,v[500001],w[500001],head[500001],nxt[500001],cnt,maxx,dist[500001]; 
bool vis[500001];
void add(int a,int b,int c)
{
    v[++cnt]=b;
    w[cnt]=c;
    nxt[cnt]=head[a];
    head[a]=cnt;
}
void read()
{
    cin>>n>>m>>s;
    for(int i=1;i<=m;i++)
    {
        cin>>x>>y>>z;
        add(x,y,z);
    }
} 
void spfa(int s)
{
    memset(dist,20,sizeof(dist));
    queue<int>q;
    q.push(s);
    vis[s]=1;
    dist[s]=0;
    while(!q.empty())
    {
        int t=q.front();
        q.pop();
        vis[t]=0;
        for(int i=head[t];i;i=nxt[i])
        {
            int y=v[i];
            if(dist[y]>dist[t]+w[i])
            {
                dist[y]=dist[t]+w[i];
                if(!vis[y])
                {
                    q.push(y);
                    vis[y]=1;
                }
            }
        }
    }
}
void pr()
{
    for(int i=1;i<=n;i++)
    {
        if(dist[i]!=inf)cout<<dist[i];
        else cout<<"2147483647";
        cout<<" ";
    } 
}
int main()
{
    read();
    spfa(s);
    pr();
    return 0;
}

　　

2、STL栈：用时: 4257ms / 内存: 8536KB（#2，#9，#10TLE）

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<queue>
#include<stack>
#include<algorithm>
#define inf 336860180
using namespace std;
int n,m,s,x,y,z,v[500001],w[500001],head[500001],nxt[500001],cnt,maxx,dist[500001]; 
bool vis[500001];
void add(int a,int b,int c)
{
    v[++cnt]=b;
    w[cnt]=c;
    nxt[cnt]=head[a];
    head[a]=cnt;
}
void read()
{
    cin>>n>>m>>s;
    for(int i=1;i<=m;i++)
    {
        cin>>x>>y>>z;
        add(x,y,z);
    }
} 
void spfa(int s)
{
    memset(dist,20,sizeof(dist));
    stack<int>q;
    q.push(s);
    vis[s]=1;
    dist[s]=0;
    while(!q.empty())
    {
        int t=q.top();
        q.pop();
        vis[t]=0;
        for(int i=head[t];i;i=nxt[i])
        {
            int y=v[i];
            if(dist[y]>dist[t]+w[i])
            {
                dist[y]=dist[t]+w[i];
                if(!vis[y])
                {
                    q.push(y);
                    vis[y]=1;
                }
            }
        }
    }
}
void pr()
{
    for(int i=1;i<=n;i++)
    {
        if(dist[i]!=inf)cout<<dist[i];
        else cout<<"2147483647";
        cout<<" ";
    } 
}
int main()
{
    read();
    spfa(s);
    pr();
    return 0;
}

　　

3、模拟栈：用时: 4242ms / 内存: 8508KB（#2，#9，#10TLE）

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<queue>
#include<stack>
#include<algorithm>
#define inf 336860180
using namespace std;
int n,m,s,x,y,z,v[500001],w[500001],head[500001],nxt[500001],cnt,maxx,dist[500001],stk[500001],top; 
bool vis[500001];
void add(int a,int b,int c)
{
    v[++cnt]=b;
    w[cnt]=c;
    nxt[cnt]=head[a];
    head[a]=cnt;
}
void read()
{
    cin>>n>>m>>s;
    for(int i=1;i<=m;i++)
    {
        cin>>x>>y>>z;
        add(x,y,z);
    }
} 
void spfa(int s)
{
    memset(dist,20,sizeof(dist));
    top=1;
    stk[top]=s;
    vis[s]=1;
    dist[s]=0;
    while(top>0)
    {
        int t=stk[top];
        top--;
        vis[t]=0;
        for(int i=head[t];i;i=nxt[i])
        {
            int y=v[i];
            if(dist[y]>dist[t]+w[i])
            {
                dist[y]=dist[t]+w[i];
                if(!vis[y])
                {
                    stk[++top]=y;
                    vis[y]=1;
                }
            }
        }
    }
}
void pr()
{
    for(int i=1;i<=n;i++)
    {
        if(dist[i]!=inf)cout<<dist[i];
        else cout<<"2147483647";
        cout<<" ";
    } 
}
int main()
{
    read();
    spfa(s);
    pr();
    return 0;
}

　　

4、STL优先队列：用时: 1377ms / 内存: 8612KB

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<queue>
#include<stack>
#include<algorithm>
#define inf 336860180
using namespace std;
int n,m,s,x,y,z,v[500001],w[500001],head[500001],nxt[500001],cnt,maxx,dist[500001],stk[500001],top; 
bool vis[500001];
void add(int a,int b,int c)
{
    v[++cnt]=b;
    w[cnt]=c;
    nxt[cnt]=head[a];
    head[a]=cnt;
}
void read()
{
    cin>>n>>m>>s;
    for(int i=1;i<=m;i++)
    {
        cin>>x>>y>>z;
        add(x,y,z);
    }
} 
void spfa(int s)
{
    memset(dist,20,sizeof(dist));
    priority_queue<int>q;
    q.push(s);
    vis[s]=1;
    dist[s]=0;
    while(!q.empty())
    {
        int t=q.top();
        q.pop();
        vis[t]=0;
        for(int i=head[t];i;i=nxt[i])
        {
            int y=v[i];
            if(dist[y]>dist[t]+w[i])
            {
                dist[y]=dist[t]+w[i];
                if(!vis[y])
                {
                    q.push(y);
                    vis[y]=1;
                }
            }
        }
    }
}
void pr()
{
    for(int i=1;i<=n;i++)
    {
        if(dist[i]!=inf)cout<<dist[i];
        else cout<<"2147483647";
        cout<<" ";
    } 
}
int main()
{
    read();
    spfa(s);
    pr();
    return 0;
}

　　

时间总的来说是这个样子的：STL栈>模拟栈>STL优先队列>STL队列

二、SPFA的优化

SPFA目前常见的优化有3种，分别是：SLF优化，LLL优化，随机优化。

1、SLF优化：

SLF优化采取的策略是开一个双端队列，如果即将入队节点大于队首值就插入前端，否则插入后端。是最常见的也是最好用的SPFA优化方法

用时: 1100ms / 内存: 8512KB

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<queue>
#include<algorithm>
#define inf 336860180
using namespace std;
int n,m,s,x,y,z,v[500001],w[500001],head[500001],nxt[500001],cnt,maxx,dist[500001],sum; 
bool vis[500001];
void add(int a,int b,int c)
{
    v[++cnt]=b;
    w[cnt]=c;
    nxt[cnt]=head[a];
    head[a]=cnt;
}
void read()
{
    cin>>n>>m>>s;
    for(int i=1;i<=m;i++)
    {
        cin>>x>>y>>z;
        add(x,y,z);
    }
} 
void spfa(int s)
{
    memset(dist,20,sizeof(dist));
    deque<int>q;
    q.push_back(s);
    vis[s]=1;
    dist[s]=0;
    while(!q.empty())
    {
        int t=q.front();
        q.pop_front();
        vis[t]=0;
        for(int i=head[t];i;i=nxt[i])
        {
            int y=v[i];
            if(dist[y]>dist[t]+w[i])
            {
                dist[y]=dist[t]+w[i];
                if(!vis[y])
                {
                    if(dist[y]<=dist[q.front()])q.push_front(y);
                    else q.push_back(y);
                    vis[y]=1;
                }
            }
        }
    }
}
void pr()
{
    for(int i=1;i<=n;i++)
    {
        if(dist[i]!=inf)cout<<dist[i];
        else cout<<"2147483647";
        cout<<" ";
    } 
}
int main()
{
    read();
    spfa(s);
    pr();
    return 0;
}

　　

2、LLL优化：

LLL优化也是开一个双端队列，每次去队首看是否大于平均值，大于就插入队尾继续寻找。看起来高大上实际应用不多的SPFA优化

用时: 1114ms / 内存: 8500KB

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<queue>
#include<algorithm>
#define inf 336860180
using namespace std;
int n,m,s,x,y,z,v[500001],w[500001],head[500001],nxt[500001],cnt,maxx,dist[500001],sum; 
bool vis[500001];
void add(int a,int b,int c)
{
    v[++cnt]=b;
    w[cnt]=c;
    nxt[cnt]=head[a];
    head[a]=cnt;
}
void read()
{
    cin>>n>>m>>s;
    for(int i=1;i<=m;i++)
    {
        cin>>x>>y>>z;
        add(x,y,z);
    }
} 
void spfa(int s)
{
    memset(dist,20,sizeof(dist));
    deque<int>q;
    q.push_back(s);
    vis[s]=1;
    dist[s]=0;
    while(!q.empty())
    {
        int t=q.front();
        if(dist[t]*q.size()>sum)
        {
        	q.pop_front();
        	q.push_back(t);
        	continue;
        }
        q.pop_front();
        sum-=dist[t];
        vis[t]=0;
        for(int i=head[t];i;i=nxt[i])
        {
            int y=v[i];
            if(dist[y]>dist[t]+w[i])
            {
                dist[y]=dist[t]+w[i];
                if(!vis[y])
                {
                	q.push_back(y);
                    sum+=dist[y];
                    vis[y]=1;
                }
            }
        }
    }
}
void pr()
{
    for(int i=1;i<=n;i++)
    {
        if(dist[i]!=inf)cout<<dist[i];
        else cout<<"2147483647";
        cout<<" ";
    } 
}
int main()
{
    read();
    spfa(s);
    pr();
    return 0;
}

　　

3、随机优化：

随机优化就是rand一下，为0插入队首，为1插入队尾，最不靠谱的优化。

用时: 1259ms / 内存: 8516KB

 

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<ctime>
#include<cstring>
#include<queue>
#include<algorithm>
#define inf 336860180
using namespace std;
int n,m,s,x,y,z,v[500001],w[500001],head[500001],nxt[500001],cnt,maxx,dist[500001],sum; 
bool vis[500001];
void add(int a,int b,int c)
{
    v[++cnt]=b;
    w[cnt]=c;
    nxt[cnt]=head[a];
    head[a]=cnt;
}
void read()
{
    cin>>n>>m>>s;
    for(int i=1;i<=m;i++)
    {
        cin>>x>>y>>z;
        add(x,y,z);
    }
} 
void spfa(int s)
{
    memset(dist,20,sizeof(dist));
    deque<int>q;
    q.push_back(s);
    vis[s]=1;
    dist[s]=0;
    while(!q.empty())
    {
        int t=q.front();
        q.pop_front();
        vis[t]=0;
        for(int i=head[t];i;i=nxt[i])
        {
            int y=v[i];
            if(dist[y]>dist[t]+w[i])
            {
                dist[y]=dist[t]+w[i];
                if(!vis[y])
                {
                	if(rand()%2)q.push_front(y);
                	else q.push_back(y);
                    vis[y]=1;
                }
            }
        }
    }
}
void pr()
{
    for(int i=1;i<=n;i++)
    {
        if(dist[i]!=inf)cout<<dist[i];
        else cout<<"2147483647";
        cout<<" ";
    } 
}
int main()
{
    srand(time(NULL));
    read();
    spfa(s);
    pr();
    return 0;
}

　　

优化后的时间排序：RAND>LLL>朴素>SLF

如果你喜欢我的文章就来个点赞收藏转发关注吧!!!

转载于:https://www.cnblogs.com/szmssf/p/11047202.html

数据结构与算法必知基础知识
bigsai
01-06 1万+
原创公众号：bigsai 文章已收录在 全网都在关注的数据结构与算法学习仓库 欢迎star 前言 数据结构与算法是程序员内功体现的重要标准之一，且数据结构也应用在各个方面，业界更有程序=数据结构+算法这个等式存在。各个中间件开发者，架构师他们都在努力的优化中间件、项目结构以及算法提高运行效率和降低内存占用，在这里数据结构起到相当重要的作用。此外数据结构也蕴含一些面向对象的思想，故学好掌握数据结构对逻辑思维处理抽象能力有很大提升。 为什么学习数据结构与算法？如果你还是学生，那么这门课程是必修的，考研基本也.
LightOJ 1074 基于stack优化的spfa 处理负权回路问题
shadandeajian的博客
07-31 160
#include&lt;iostream&gt; #include&lt;cstring&gt; #include&lt;cstdio&gt; #include&lt;stack&gt; #include&lt;queue&gt; using namespace std; const int maxv=210; const int maxe=210*210; const int INF=0x3f...
POJ3159Candies（差分约束系统）
Hawkeye_z的博客
11-03 591
DescriptionDuring the kindergarten days, flymouse was the monitor of his class. Occasionally the head-teacher brought the kids of flymouse’s class a large bag of candies and had flymouse distribute the
Candies POJ 3159 （堆优化的SPFA，）
hi_just_do_it的博客
07-14 870
开始看半天看不懂题目意思，原来是~~~ 分差约束系统： 全都是两个未知数的差小于等于某个常数（大于等于也可以，因为左右乘以-1就可以化成小于等于）。这样的不等式组就称作差分约束系统。 也就是说求1到N的最短路就行了。 但是这道题数据比较大，m = 150000，只能用堆优化的SPFA
BZOJ 1179 APIO2009 ATM Tarjan+堆优化SPFA
世界
11-02 1674
题目大意：给定一个有向图，每个点上有正权，求一条从起点出发到任意终点的路径，要求路上的点权和最大(一个点权只能被加一次) 首先Tarjan缩点，易知一个强连通分量内任意一个点权拿到就可以拿到强连通分量内所有的点权 然后这个图就没有环了，SPFA跑最长路即可 边数500W，所以要加堆优化 #include #include #include #include #define M 500500
浅谈spfa几个优化
ba82586628365094的博客
04-10 319
优化一：每次更新节点时，记录当前走的这条路径的节点数，当节点数大于n时，有负环，退出。注意，这里与常规的节点被更新n次以上退出不一样，效率比常规高。 优化二：双端队列SLF优化。当当前节点到起点距离小于队首的时候，将此点插入队首，否则，正常插入队尾。可能咋一看感觉这种优化可能被用到的机会很少，但很可能正好解决掉了专门卡spfa的数据以及网格图。 优化三：与优化二类似，但改为小于队列元...
SPFA算法的优化及应用.ppt
09-17
因此，有人提出使用深度优先搜索（DFS）的方式，即SPFA_Dfs，利用栈这一数据结构，从最近被更新的节点开始递归进行迭代，当在搜索栈中遇到已经遍历过的节点时，即可判断存在负权环。 DFS在检测负权环方面具有优势，...
spfa.rar_SPFA
09-20
与Bellman-Ford算法每次迭代更新所有边不同，SPFA通过队列数据结构进行优化，从而减少了无效的路径更新，提高了算法的运行速度。 ### SPFA算法的基本思想 SPFA算法基于贪心策略，采用一个优先级队列（通常用FIFO的...
SPFA.zip_SPFA
09-20
SPFA算法是基于Bellman-Ford算法的一种优化版本，由刘辉（Hui Liu）提出。它的核心思想是使用一个队列来存储待更新的顶点，相比于Bellman-Ford算法的每轮遍历所有顶点，SPFA通过优先处理队列中的顶点来提高效率。...
SPFA算法优化探索：应用与动态规划的结合
3. 针对具体问题进行优化，比如在差分约束系统中，可以通过特殊的数据结构和剪枝策略来提高求解速度。 在实际应用中，SPFA算法不仅限于最短路径问题，还可以应用于： 1. 动态规划问题，尤其是在状态转移阶段性不...
SPFA的堆栈实现
ll365594480的专栏
10-04 512
SPFA的堆栈实现 算法简介           SPFA(Shortest Path Faster Algorithm)是Bellman-Ford算法的一种优化，减少了不必要的冗余计算。它可以在O(kE)的时间复杂度内求出源点到其他所有点的最短路径，可以处理负边，但判断负回
poj3159 Candies（差分约束 ：基于栈的SPFA | 堆优化的Dijkstra）
一身清贫怎敢入繁华
09-18 290
题意 现在给n个小朋友分糖果，给出m条语句Ａ B C表示小朋友A认为给B的糖果不能比自己多C(可以等于C)，问小朋友N与小朋友1的糖果数量差最大是多少 思路： 差分约束。将这种不等关系转化为图中的一条有向边，最后以1为源点跑一遍最短路，最后d[ n ] 就是答案。这题问的是1与N差值，所以不必管每个小盆友至少分的糖果的情况。 spfa + 栈 500 - 600 ms AC Co...
请问spfa+stack 和spfa+queue 是什么原理
weixin_30788731的博客
03-19 154
一个是bfs加迭代 一个是dfs加迭代 请问迭代是什么 就是不断地做，做到没有更优的解为止 或者是不断得做，做到逼近答案为止。。 栈比队列更快更节省空间 转载于:https://www.cnblogs.com/thefirstfeeling/p/4410831.html...
spfa的玄学优化
smoggyxhdz的博客
05-19 815
  算法提高 道路和航路  时间限制：1.0s   内存限制：256.0MB     问题描述农夫约翰正在针对一个新区域的牛奶配送合同进行研究。他打算分发牛奶到T个城镇（标号为1..T），这些城镇通过R条标号为（1..R）的道路和P条标号为（1..P）的航路相连。每一条公路i或者航路i表示成连接城镇Ai（1&lt;=A_i&lt;=T）和Bi（1&lt;=Bi&lt;=T）代价为Ci。每一条公路...
spfa和堆优化的dij和prim
WINDZLY的博客
12-04 680
1 spfa虽然已经死了，可是他还有一个作用就是判断负环和正环（如果在一个点跑了大于n次那么这个图就存在负环）正环跑最长路，负环跑最短路 /* I am nothing but I must be everything. */ #include &lt;map&gt; #include &lt;cmath&gt; #include &lt;stack&gt; #include &lt;queu...
Spfa 算法 以及 两种优化 -- Til the Cows Come Home
MM_Silence
03-24 235
题目链接：http://poj.org/problem?id=2387 /* 可以判定负环，负权边的spfa算法 BFS版本用于计算最短路径 */ # include &lt;iostream&gt; # include &lt;string.h&gt; # include &lt;string&gt; # include &lt;algorithm&gt; # include &...
POJ 3159 Candies 【差分约束系统 dijkstra+heap/spfa+stack】
指弹键盘哼民谣
02-09 450
POJ 3159 Candies 题目链接：vjudge传送门 题目大意： 给n个人分糖果，m组数据a，b，c；意思是a比b少的糖果个数绝对不超过c个，也就是d(b)-d(a) < c，求1比n少的糖果数的最大值。 具体思路： 差分约束系统第一次接触，我也不太懂，见博客 据说spfa+queue会超时，看好多人都用spfa+stack优化【第一次知道能用stack优化，但是我仍不知两者的差别...
SPFA
weixin_44368514的博客
02-13 1314
SPFA算法； 思想： 逼近 + 松弛 + bfs; 用途： 点对点的（现在还不清楚），图中可以有负环路。 1，将源点压入队列 2，取出队头元素，对该元素的各邻接边进行松弛操作。如果该点没有在队列中，就压入队列 3，重复步骤 1. 判断是否有负环： 如果任意一点的入队次数超过了顶点数，则说明有负环。 int SPFA(int sour, int g[][501]) // sour 源点 ； ...
SPFA算法模板
winycg的博客
09-16 2091
SPFA算法 优化时每次取出队首结点u，并且用u点当前的最短路径估计值对离开u点所指向的结点v进行松弛操作，如果v点的最短路径估计值有所调整，且v点不在当前的队列中，就将v点放入队尾。这样不断从队列中取出结点来进行松弛操作，直至队列空为止 //算法判环并输出最短路径，边从0开始，点都可以 struct Edge { int from,to,dist; }; vector edg
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值