Dijkstra堆优化（pbds版本priority_queue）

最新推荐文章于 2024-07-24 10:46:35 发布
最新推荐文章于 2024-07-24 10:46:35 发布
阅读量898 收藏 3
点赞数 3
分类专栏： 数据结构 其他 文章标签： python c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gh0st_lx/article/details/120568099
版权

目录

背景

防止赛场上面被卡SPFA，且效率更高更稳定

测试

测试了STL的，和pbds的优先队列，在Dijkstra堆优化中谁更快

STL，初始堆中只有一个元素（起点）：141-252ms
在这里插入图片描述
STL，初始堆中有n个元素:238-384ms
在这里插入图片描述

  • pbds，初始堆中只有一个元素（起点）：62-110ms
    在这里插入图片描述
  • pbds，初始堆中有n个元素：75-130ms
    在这里插入图片描述
    手写堆，初始堆中有所有元素：39-69ms

此处手写堆就没有对照实验了，手写堆还是快的离谱hhh

在这里插入图片描述

  • 综上测试，使用pbds里面可修改的优先队列，速度还是比STL里面快的，且初始时，堆中仅有一个起点的时候更快。
  • 但是如果没有修改和合并的情况，一般还是STL里的堆更快

代码实现

pb_ds写法
  • pbds，初始堆中只有一个元素（起点）
#include <bits/stdc++.h>
#include <bits/extc++.h>
#include <unordered_map>
#include <unordered_set>
using namespace std;
using namespace __gnu_cxx;
using namespace __gnu_pbds;

#define debug(x) cerr << #x << ": " << x << '\n'
#define bd cerr << "----------------------" << el
#define el '\n'
#define cl putchar('\n')
#define pb push_back
#define eb emplace_back
#define x first
#define y second
#define rep(i, a, b) for (register int i = (a); i <= (b); i++)
#define loop(i, a, b) for (int i = (a); i < (b); i++)
#define dwn(i, a, b) for (int i = (a); i >= (b); i--)
#define ceil(a, b) (a + (b - 1)) / b
#define ms(a, x) memset(a, x, sizeof(a))
#define INF 0x3f3f3f3f
#define db double

typedef long long LL;
typedef long double LD;
typedef pair<int, int> PII;
typedef pair<db, db> PDD;
typedef vector<int> vci;
typedef map<int, int> mii;
typedef mii::iterator mii_it;

const int N = 1e5 + 10, M = 2e6 + 10, E = 1e3 + 10, md = 1e9 + 7;
const double PI = acos(-1), eps = 1e-8;

int T, n, m;
#define param PII, greater<PII>, pairing_heap_tag
__gnu_pbds::priority_queue<param> q;
__gnu_pbds::priority_queue<param>::point_iterator its[N];
int dis[N];
vector<PII> g[N];
inline int read()
{
	int f = 1, d = 0;
	char ch;
	ch = getchar();
	while(ch < '0' || ch > '9')
	{
		if(ch == '-') f = -1;
		ch = getchar();
	}
	while(ch >= '0' && ch <= '9')
		d = (d << 1) + (d << 3) + (ch ^ 48), ch = getchar();
	return d * f;
}


void dijkstra(int sta)
{
    q.clear();
    for (int i = 1; i <= n; i++)
    {
        dis[i] = INF; //堆根据first排序，所以dis要放在前面,id放在后面
        
    }
    its[sta] = q.push({0, sta});
    dis[sta] = 0;
    int u;
#define v first
#define w second
    while (!q.empty())
    {
        u = q.top().second;
        q.pop();
        for (auto e : g[u])
        {
            if (dis[e.v] > dis[u] + e.w)
            {
                dis[e.v] = dis[u] + e.w;
                if(its[e.v]!=NULL)q.modify(its[e.v], {dis[e.v], e.v});
                else {
                    its[e.v] = q.push({dis[e.v], e.v});
                }
            }
        }
    }
#undef v
#undef w
    return;
}

int main()
{
    cin.tie(0);
    cout.tie(0);
    cin.sync_with_stdio(false);
    int s;
    // cin >> n >> m >> s;
    n = read();
    m = read();
    s = read();
    int u, v, w;
    rep(i, 1, m)
    {
        // cin >> u >> v >> w;
        u = read();
        v = read();
        w = read();
        g[u].eb(v, w);
    }
    dijkstra(s);
    rep(i, 1, n) if (dis[i] != INF) cout << dis[i] << ' ';
    else cout << INT_MAX << ' ';
}
STL写法
#include <bits/stdc++.h>
#include <bits/extc++.h>
#include <unordered_map>
#include <unordered_set>
using namespace std;
using namespace __gnu_cxx;
using namespace __gnu_pbds;

#define debug(x) cerr << #x << ": " << x << '\n'
#define bd cerr << "----------------------" << el
#define el '\n'
#define cl putchar('\n')
#define pb push_back
#define eb emplace_back
#define x first
#define y second
#define rep(i, a, b) for (register int i = (a); i <= (b); i++)
#define loop(i, a, b) for (int i = (a); i < (b); i++)
#define dwn(i, a, b) for (int i = (a); i >= (b); i--)
#define ceil(a, b) (a + (b - 1)) / b
#define ms(a, x) memset(a, x, sizeof(a))
#define INF 0x3f3f3f3f
#define db double

typedef long long LL;
typedef long double LD;
typedef pair<int, int> PII;
typedef pair<db, db> PDD;
typedef vector<int> vci;
typedef map<int, int> mii;
typedef mii::iterator mii_it;

const int N = 1e5 + 10, M = 2e6 + 10, E = 1e3 + 10, md = 1e9 + 7;
const double PI = acos(-1), eps = 1e-8;

int T, n, m;
std::priority_queue<PII, vector<PII>, greater<PII>> q;
int dis[N];
bool vis[N];
vector<PII> g[N];
inline int read()
{
    int f = 1, d = 0;
    char ch;
    ch = getchar();
    while (ch < '0' || ch > '9')
    {
        if (ch == '-')
            f = -1;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9')
        d = (d << 1) + (d << 3) + (ch ^ 48), ch = getchar();
    return d * f;
}

void dijkstra(int sta)
{

    for (int i = 1; i <= n; i++)
    {
        dis[i] = INF; //堆根据first排序，所以dis要放在前面,id放在后面
        if(i != sta) q.push({INF, i});
        else q.push({0, sta});
    }

    dis[sta] = 0;
    // q.push({0, sta});
    int u;
    while (!q.empty())
    {
        u = q.top().second;
        q.pop();
        if (vis[u])
            continue;
        vis[u] = 1;
        for (auto e : g[u])
        {
            if (dis[e.first] > dis[u] + e.second)
            {
                dis[e.first] = dis[u] + e.second;
                q.push({dis[e.first], e.first});
            }
        }
    }
    return;
}

int main()
{
    cin.tie(0);
    cout.tie(0);
    cin.sync_with_stdio(false);
    int s;
    // cin >> n >> m >> s;
    n = read();
    m = read();
    s = read();
    int u, v, w;
    rep(i, 1, m)
    {
        // cin >> u >> v >> w;
        u = read();
        v = read();
        w = read();
        g[u].eb(v, w);
    }
    dijkstra(s);
    rep(i, 1, n) if (dis[i] != INF) cout << dis[i] << ' ';
    else cout << INT_MAX << ' ';
}
手写堆
  • 手写堆，初始堆内有n个元素

#include<bits/stdc++.h>
using namespace std;
const int mx=1e5+10;
const int mn=1e6+10;
const int Max=0x3f3f3f3f;
struct Graph {
	int to,nex,w;
} e[mn];
int last[mx],tot;
void addedge(int from,int to,int w) {
	e[++tot].to=to;
	e[tot].nex=last[from];
	e[tot].w=w;
	last[from]=tot;
}

int n,m,sta,des,cnt,pos[mx],Hsize,pre[mx];
bool s[mx];

//最小堆 
struct dui{
	int d,id;
	//d代表dis距离 
}Heap[mx];

//Heap[0]是中间变量
//Heap[1]是堆顶 
void swap(int a,int b){
	//pos代表  编号在堆中的位置，Heap代表堆中所储存的信息(距离和编号) 
	Heap[0]=Heap[a];
	Heap[a]=Heap[b];
	Heap[b]=Heap[0];
	//里面储存的其实已经是b的信息了 
	pos[Heap[a].id]=a;
	pos[Heap[b].id]=b;
}

void Up(int i){//上浮 
	while((i != 1) &&( Heap[i].d < Heap[i>>1].d )){
		swap(i,i >> 1);
		i >>= 1;
	}
}

void Delete(){
	swap(1,Hsize);//删除堆顶 
	Hsize--;
	//下沉 
	int Par,Chi;
	for(Par=1;Par << 1 <=Hsize;Par=Chi){
		Chi=Par << 1;
		if(Chi+1<=Hsize&&Heap[Chi].d>Heap[Chi+1].d)Chi++;//选择出来，比较小的那个儿子 
		if(Heap[Par].d<Heap[Chi].d)break;//如果父亲已经比两个儿子都小，则合法，break 
		swap(Par,Chi);//交换二者 
	}
}

void Relax(int u,int v,int w){//放松w边 
	if(w + Heap[pos[u]].d<Heap[pos[v]].d){
		Heap[pos[v]].d=w + Heap[pos[u]].d;
		pre[v]=u;//v的前驱是u 
		Up(pos[v]);//上浮，跟父亲比较 
	}
}

void dijkstra(){
	for(int i=1;i<=n;i++){
		Heap[i].id=pos[i]=i;
		Heap[i].d=Max;//赋最大值 
	}
	Heap[sta].d=0;
	swap(1,sta);//起点弄到堆顶 
	Hsize=n;
	int u,v;
	while(Hsize){
		u=Heap[1].id;
		Delete();
		for(int i=last[u];i;i=e[i].nex){
			v=e[i].to;
			if(pos[v]<=Hsize)Relax(u,v,e[i].w);//放松边 
		}
	}
}

int main() {
	scanf("%d%d%d",&n,&m,&sta);//顶点数 边数 起点 终点 
	for(int i=1; i<=m; i++) {
		int u,v,w;
		scanf("%d%d%d",&u,&v,&w);
		addedge(u,v,w);
//		addedge(v,u,w);
	}
	dijkstra(); 
	for(int i = 1; i <= n; i ++ )
	{
		if(Heap[pos[i]].d != Max) cout << Heap[pos[i]].d << ' ';
		else cout << INT_MAX << ' ';
	}
//	printf("%d\n",Heap[pos[des]].d); 
	//编号为des的信息在堆中并没有被舍弃，只是在Dijkstra中访问不到了 
	
}
Gh0st_Lx
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
PriorityQueue+Dijkstra优先队列优化的Dijkstra
桦楠雨蝶
05-11 8214
前面分别介绍了“原生的Dijkstra”即毫无优化的Dijkstra，但这种Dijkstra的效率较低为n^n，因此面对较大数据量的时候需要对其进行优化，也就是优化所采用的贪心策略的实现，因此就有了Heao+Dijkstra堆优化的Dijkstra，但是堆优化的实现很复杂，而PriorityQueue+Dijkstra优先队列优化的Dijstra的效率虽然略低于堆优化的Dijkstra，但是实现却容易的多，也不容易出错，因为可以借助java类库中的PriorityQueue来实现，因此优先队列优化的Dijk
pb_ds（Policy-Based Data Structures）
追风蹑影
07-18 2486
参考：http://blog.csdn.net/wjf_wzzc/article/details/38851703 《C++的pb_ds库在OI中的应用》大连市第二十四中学 于纪平 http://blog.csdn.net/wmdcstdio/article/details/44596305 一、 pb_ds 库全称 Policy-Based Data Structures It
Dijkstra + priority_queue
tjf的专栏
11-24 988
模版 EOJ 最短路：http://acm.cs.ecnu.edu.cn/problem.php?problemid=1817 #include #include #include #include #include #include #include #include #include #include #include using namespace std; t
算法刷题笔记 堆优化版的Dijkstra算法求最短路（C++实现。包含详细思路分析和对C++中priority_queue的介绍）
最新发布
hanmo22357的博客
07-24 759
一道较难的算法题，但是仍然属于一道模板题，给出了详细的思路分析，以及对C++中的优先队列的介绍。最后，本文给出了非常详细注释的C++代码实现。
Dijkstra+priority_queue
qq_21514205的博客
08-21 319
转载自：http://www.cnblogs.com/qijinbiao/archive/2012/10/04/2711780.html 重点是算法的松弛操作，在算法内 一个Node节点的含义：x表示自己，d表示dis[x]  即:点和源点到该点的距离 while(!q.empty())     {         node x=q.top();q.pop();         for(
Dijkstra+Priority_queue
HeKai的博客
06-06 569
模板#include<iostream> #include<cstdio> #include<queue> using namespace std; int n,m,S,tot,Next[500010],head[20000],tree[500010],val[500010]; bool visit[20000]; long long dis[20000]; struct cmp { boo
使用优先队列priority_queue来优化Dijkstra
weixin_44321570的博客
03-10 354
代码如下： #include<bits/stdc++.h> using namespace std; struct node{ int u,dis; node(){} node(int _u,int d):u(_u),dis(d){} bool operator < (const node &b)const{ return dis > b.dis; } }; const int maxn = 1000; const
【Dijkstra堆优化】【BZOJ 3040】 最短路(road)
jmsyzsfq的博客
10-04 713
传送门~Descriptionsubmit Time Limit: 60 Sec Memory Limit: 200 MBN个点，M条边的有向图，求点1到点N的最短路（保证存在）。 1<=N<=1000000，1<=M<=10000000Input第一行两个整数N、M，表示点数和边数。 第二行六个整数T、rxa、rxc、rya、ryc、rp。前T条边采用如下方式生成： 1.初始化x=y=z
平板电视（pb_ds）详解
cyyyyds857的博客
09-23 928
平板电视，也就是pb_ds，全称是 Policy-Based Data Structures。是C++中的一个库（类似于STL），其中封装了许多高级的数据结构，例如堆，字典树，平衡树，哈希表等等。平板电视也可以用来写红黑树，AVL等高级数据结构及算法（虽然我对此一窍不通），是那些懒得写高级数据结构的dalao的福音。另外，声明一下，平板电视应用在于_gnu_pbds的命名空间中，由于NOI在2021年才允许使用由下划线开头的函数。所以，平板电视在2021时才被CCF允许使用。
pb_ds库在OI中的应用
08-24
测试涵盖了堆排序、堆的合并以及堆优化的Dijkstra算法等场景。测试结果显示，在开启或未开启编译器优化选项（如GCC的O2优化）的情况下，pb_ds库中的不同堆类型在不同操作上均表现出优于STL标准容器的性能。 总的来...
基于最大堆实现的优先队列。
Hello什么来着？
04-21 367
一、概念 普通的队列是一种先进先出的数据结构，元素在队列尾追加，而从队列头删除。在优先队列中，元素被赋予优先级。当访问元素时，具有最高优先级的元素最先删除。优先队列具有最高级先出 （first in, largest out）的行为特征。通常采用堆数据结构来实现。 二、代码实现 import 队列.Queue; public class PriorityQueue<E extends ...
基于priority_queue的Dijkstra
KylinSchmidt的博客
11-20 132
代码引自https://www.cnblogs.com/mudrobot/p/13328920.html #include<bits/stdc++.h>//全库 #define N 100005 //节点总数 #define gc() getchar() using namespace std; struct sd{ int val,to,next; sd(){} bool operator < (const sd & kyl) const{//运算符重定义 ret
(模板） Dijkstra算法（priority_queue优化）
HumveeA6的博客
03-04 1328
写法1，利用struct存当前最近点的信息： #include&lt;cstdio&gt; #include&lt;iostream&gt; #include&lt;vector&gt; #include&lt;algorithm&gt; #include&lt;cstring&gt; #include&lt;queue&gt; using namespace std; struct edg...
最短路模板：使用priority_queue实现的Dijkstra算法
AC，∑ndless
02-15 4809
#include #include #include #include #include #include using namespace std; const int mx = 10005; typedef pair P; ///first是最短距离，second是顶点编号 struct edge { int to, cost; }; vector G[mx]; int disTo[mx]
pb_ds的优先队列实现dijkstra
08-30 174
用pb_ds的优先队列来做dijkstra。。据说noip能用哟。 先来篇关于仿函数的文章。 由于pb_ds支持由迭代器访问元素，并且push操作会返回一个迭代器，merge操作会更新迭代器，相当于帮你实现了根据编号找元素的功能（每个元素对应一个迭代器）。但是由于dijkstra在取出堆顶元素以后还要知道堆顶元素的编号，于是我们可以自己搞一个结构体，然后弄一个仿函数。。这样就完成了。...
Dijkstra with priority queue
天I火的小窝
07-23 592
POJ 1511 Invitation Cards（单源最短路，优先队列优化的Dijkstra）
使用priority _queue 对Dijkstra进行优化
04-22 1568
对于图的相关算法如最小生成树的Kruskal，Prim算法，最短路径的Dijkstra算法都采用的是贪心算法，而贪心算法最好的辅助工具个人认为就是priority_queue.所以本文将运用priority_queued对算法导论中Dijkstra算法进行优化。对于Dijkstra算法我们先给出算法导论中所给出基本算法实现。 int a[5][5] = { {MAX2,10,M
Dijkstra pb_ds优化
weixin_30839881的博客
07-20 116
　　由于用优先队列的Dijkstra在队列中一个点可能出现很多次，所以复杂度为 O(n+m)log(n+m)，但是pd_ds优化的Dijkstra，复杂度可以达到 O(n+m)log(n)。 　　注：pb_ds中不会自动去重。 　　代码： 　 #include<cstdio> #include<iostream> #include<queue> ...
priority_queue 堆
10-18
好的，你的问题是 "priority_queue 堆"，我来回答一下。 priority_queue 是 C++ STL 中的一个容器适配器，它是基于 vector 或 deque 实现的堆。堆是一种特殊的树形数据结构，它满足堆的性质：对于每个节点 x，它的父节点的值不大于 x 的值（最大堆），或者不小于 x 的值（最小堆）。priority_queue 可以用来实现堆排序、Dijkstra 算法等。 在 priority_queue 中，元素的插入和删除操作都是 O(log n) 的时间复杂度。可以通过重载运算符来定义元素之间的比较方式，从而实现最大堆或最小堆。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值