单源最短路的建图方式（Dijkstra）

于 2023-01-29 21:05:42 发布
阅读量611 收藏
点赞数 5
分类专栏： 图论基础 文章标签： 算法 c++ 数据结构 单源最短路（Dijkstra）
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60523890/article/details/128793233
版权

由于是复习，所以不会解释太多。

主要为Dijkstra的堆优化板子和朴素版（看数据范围）

再次看看时间复杂度[ n 为点数，m 为边数 ]：朴素版：O(n^{2})，堆优化版：O( (n+m)logm )。

目录

1.热浪（Acwing 1129）

2.信使（Acwing 1128）

3.香甜的黄油（Acwing 1127）

4.最小花费（Acwing 1126）

方法一（求边权乘积最大）： 

方法二（用 log 函数 转化为加法，传统“最短路”）：

5.最优乘车（Acwing 920）

6.昂贵的聘礼（Acwing 903）

重点：建图

 1.热浪（Acwing 1129）

来源：《信息学奥赛一本通》 , USACO

题目：

 一个很裸的最短路板子，附上堆优化的板子：

#include<iostream>
#include<queue>
using namespace std;
const int N=3e3,M=2e5+6;
const int inf=0x3f3f3f3f;
int n,m,s,t,ct,head[N],dis[N],vis[N];
struct edge{
	int to,w,nxt;
}e[M];
struct ty{
	int x,dis;
	bool operator < (const ty &a)const{
		return dis>a.dis;
	}
}tp;
priority_queue<ty>q;
void add(int u,int v,int w){
	e[++ct].to=v;
	e[ct].w=w;
	e[ct].nxt=head[u];
	head[u]=ct;
}
int Dij(){
	for(int i=1;i<=n;i++)dis[i]=inf;
	dis[s]=0;
	q.push((ty){s,0});
	while(!q.empty()){
		tp=q.top();
		q.pop();
		int u=tp.x;
		if(vis[u])continue;
		vis[u]=1;
		for(int i=head[u];i;i=e[i].nxt){
			int v=e[i].to;
			if(vis[v])continue;
			if(dis[v]>dis[u]+e[i].w){
				dis[v]=dis[u]+e[i].w;
				q.push((ty){v,dis[v]});
			}
		}
	}
	return dis[t];
}
int main(){
	ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
	cin>>n>>m>>s>>t;
	for(int i=0,u,v,w;i<m;i++){
		cin>>u>>v>>w;
		add(u,v,w);
		add(v,u,w);
	}
	cout<<Dij(); 
	return 0;
}

2.信使（Acwing 1128）

来源：《信息学奥赛一本通》

题目：

 求出指挥部到每个点的最短路，答案为所有最短时间中的最大值。（要最后跑完的也跑完才算完成）所以也就是多个Dijkstra:

#include<iostream>
#include<algorithm>
#include<queue>
using namespace std;
const int inf=0x3f3f3f3f;
int n,m,ct,ans,head[105],dis[105],vis[105];
struct edge{
	int to,w,nxt;
}e[410];
struct ty{
	int x,dis;
	bool operator < (const ty &a)const{
		return dis>a.dis;
	}
}tp;
priority_queue<ty>q;
void add(int u,int v,int w){
	e[++ct].to=v;
	e[ct].w=w;
	e[ct].nxt=head[u];
	head[u]=ct;
}
int Dij(int t){
	for(int i=1;i<=n;i++)
		dis[i]=inf,vis[i]=0;
	dis[1]=0;
	q.push((ty){1,0});
	while(!q.empty()){
		tp=q.top();
		q.pop();
		int u=tp.x;
		if(vis[u])continue;
		vis[u]=1;
		for(int i=head[u];i;i=e[i].nxt){
			int v=e[i].to;
			if(vis[v])continue;
			if(dis[v]>dis[u]+e[i].w){
				dis[v]=dis[u]+e[i].w;
				q.push((ty){v,dis[v]});
			}
		}
	}
	return dis[t];
}
int main(){
	ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
	cin>>n>>m;
	for(int i=0,u,v,w;i<m;i++){
		cin>>u>>v>>w;
		add(u,v,w);
		add(v,u,w);
	}
	for(int i=2;i<=n;i++)
		ans=max(ans,Dij(i));
	cout<<(ans==inf?-1:ans);
	return 0;
}

3.香甜的黄油（Acwing 1127）

来源：《信息学奥赛一本通》 , usaco training 3.2

题目：

 枚举答案牧场，求出每个有牛的牧场到答案牧场的最短距离和（有几头牛就将那个牧场路径乘以几）还是堆优化的代码：

#include<iostream>
#include<algorithm>
#include<queue>
using namespace std;
const int M=805,inf=0x3f3f3f3f;
int n,m,p,ct,a[M],head[M],dis[M],vis[M];
struct edge{
	int to,w,nxt;
}e[3000];
struct ty{
	int x,dis;
	bool operator < (const ty &a)const{
		return dis>a.dis;
	}
}tp;
priority_queue<ty>q;
void add(int u,int v,int w){
	e[++ct].to=v;
	e[ct].w=w;
	e[ct].nxt=head[u];
	head[u]=ct;
}
int Dij(int s){
	for(int i=1;i<=p;i++)
		dis[i]=inf, vis[i]=0;
	dis[s]=0;
	q.push((ty){s,0});
	while(!q.empty()){
		tp=q.top();
		q.pop();
		int u=tp.x;
		if(vis[u])continue;
		vis[u]=1;
		for(int i=head[u];i;i=e[i].nxt){
			int v=e[i].to;
			if(vis[v])continue;
			if(dis[v]>dis[u]+e[i].w){
				dis[v]=dis[u]+e[i].w;
				q.push((ty){v,dis[v]});
			}
		}
	}
	int sum=0;
	for(int i=1;i<=p;i++){
		if(a[i]&&dis[i]==inf)return inf;//注意：没牛的牧场没必要连通
		sum+=dis[i]*a[i];
	}
	return sum;
}
int main(){
	ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
	cin>>n>>p>>m;
	for(int i=0,x;i<n;i++){
		cin>>x;
		a[x]++;
	}
	for(int i=0,u,v,w;i<m;i++){
		cin>>u>>v>>w;
		add(u,v,w);
		add(v,u,w);
	}
	int ans=inf;
	for(int i=1;i<=p;i++)
		ans=min(ans,Dij(i));
	cout<<ans;
	return 0;
}

4.最小花费（Acwing 1126）

来源：《信息学奥赛一本通》

题目：

方法一（求边权乘积最大）： 

扣除 z% 的手续费其实就是变为原来的（1-z%）将最短路板子的边权换作该比例，求乘积最大值，由于从“最短路”变为求“最大”，所以此时堆优化板子的优先队列的优先级也跟原来相反，应先弹出“最大值”。

方法二（用 log 函数 转化为加法，传统“最短路”）：

要使 w_{1}w_{2}w_{3}...w_{n} 最大，对其取 log ，因为单调性一致，相当于求 log w_{1}+log w_{2}+log w_{3}+...+log w_{n} 最大值，又因为 w=(1 - z%) <= 1，所以logw 的值都为负数，求负数的最大值，可对所有边先乘上 -1，将其转化为正数再求正数的最小值。即边权的和的最小值-->转换为“传统”最短路写法。

当然方法二只是告诉我们这道题可以用原始最短路的写法来写，但是真用 log 函数转换比较复杂，这里直接用方法一即可。

数据比较小，可以用朴素Dijkstra写法（即用邻接表）此处附上两种写法：

1.堆优化版：

#include<iostream>
#include<algorithm>
#include<queue>
using namespace std;
const int N=2010,M=2e5+5;
int n,m,ct,s,t,head[N],vis[N];
double dis[N];
struct edge{
	int to,nxt;
	double w;
}e[M];
struct ty{
	int x;
	double dis;
	bool operator < (const ty&a)const{
		return dis<a.dis;
	}
};
priority_queue<ty>q;
void add(int u,int v,double w){
	e[++ct].to=v;
	e[ct].w=w;
	e[ct].nxt=head[u];
	head[u]=ct;
}
void Dij(){
	dis[s]=1;
	q.push((ty){s,1});
	while(!q.empty()){
		int u=q.top().x;
		q.pop();
		if(vis[u])continue;
		vis[u]=1;
		for(int i=head[u];i;i=e[i].nxt){
			int v=e[i].to;
			if(vis[v])continue;
			if(dis[v]<dis[u]*e[i].w){
				dis[v]=dis[u]*e[i].w;
				q.push((ty){v,dis[v]});
			}
		}
	}
}
int main(){
	ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
	cin>>n>>m;
	for(int i=0,x,y,z;i<m;i++){
		cin>>x>>y>>z;
		add(x,y,(100-z)*0.01);
		add(y,x,(100-z)*0.01);
	}
	cin>>s>>t;
	Dij();
	printf("%.8f",100/dis[t]);
	return 0;
}

2.朴素版：

#include<cstdio>
#include<algorithm>
using namespace std;
const int N=2e3+5;
int n,m,s,t,vis[N];
double a[N][N],dis[N];
void Dij(){
	dis[s]=1;
	for(int i=1;i<=n;i++){
		int t=-1;
		for(int j=1;j<=n;j++)
			if(!vis[j]&&(t==-1||dis[j]>dis[t]))t=j;
		vis[t]=1;
		for(int j=1;j<=n;j++)
			dis[j]=max(dis[j],dis[t]*a[t][j]);
	}
}
int main(){
	scanf("%d%d",&n,&m);
	for(int i=0,x,y,z;i<m;i++){
		scanf("%d%d%d",&x,&y,&z);
		a[x][y]=a[y][x]=(100-z)*0.01;
	}
	scanf("%d%d",&s,&t);
	Dij();
	printf("%.8f",100/dis[t]);
	return 0;
}

5.最优乘车（Acwing 920）

来源：NOI1997

题目：

 换乘次数=乘车次数 - 1，考虑乘车次数，读懂题意，单程车，比如 4 7 3 6这条，4-7，4-3，7-6都是一次乘车，我们可以建图将一条公交路线上的点与其后所有的站点连边，边权为1，即一个公交路线的所有乘车情况。再求最短路即可，又因为边权都是1，所以可以bfs.

还有不得不提的是本题的输入，可以用 sstream 的 stringstream.

#include<iostream>
#include<string>
#include<cstring>
#include<sstream>
#include<queue>
using namespace std;
const int N=510,inf=0x3f3f3f3f;
int n,m,a[N],mp[N][N],dis[N];
string s;
queue<int>q;
void bfs(){
	memset(dis,0x3f,sizeof dis);
	dis[1]=0;
	q.push(1);
	while(!q.empty()){
		int tp=q.front();
		q.pop();
		for(int i=1;i<=n;i++){
			if(mp[tp][i]&&dis[i]>dis[tp]+1){
				dis[i]=dis[tp]+1;
				q.push(i);
			}
		}
	}
}
int main(){
	ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
	cin>>m>>n;
	getline(cin,s);
	while(m--){
		getline(cin,s);
		stringstream ss(s);
		int x,ct=0;
		while(ss>>x)a[ct++]=x;
		for(int i=0;i<ct;i++)
			for(int j=i+1;j<ct;j++)mp[a[i]][a[j]]=1;
	}
	bfs();
	if(dis[n]==inf)cout<<"NO";
	else cout<<(dis[n]>1?dis[n]-1:0);
	return 0;
}

6.昂贵的聘礼（Acwing 903）

来源：POJ1062 , kuangbin专题

题目：

 重点：建图

1.超级原点的思想（这种思想其实很普遍很常见）：建立一个原点0，使它能到所有的点（物品），边权为该物品的购买的价格。

2.物品A 由 物品B + 金币换得：在点B到A之间连单向边，边权为还需加上的金币数。

3.等级限制的处理：枚举区间，区间最长为 m+1，必须要包括物品1，则枚举区间左端点 left: [ level[1] - m, level[1] ]，则右端点 right 为 left + m，每次 Dijkstra 只对等级在 left 和 right 之间的转移。取每次Dijkstra 的dis[1] 的最小值。

由于点数很小，所以用的朴素版Dijkstra.

注意：初始化邻接表为无穷大，因为未提及的方案不能转移。（否则遍历时边权为0会出错）

代码：

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int N=110;
int m,n,lev[N],e[N][N],dis[N];
bool vis[N];
int Dij(int l,int r){
	memset(dis,0x3f,sizeof dis);
	memset(vis,0,sizeof vis);
	dis[0]=0;
	for(int i=1;i<=n;i++){
		int t=-1;
		for(int j=0;j<=n;j++){
			if(!vis[j]&&(t==-1||dis[t]>dis[j]))t=j;
		}
		vis[t]=1;
		for(int j=1;j<=n;j++){
			if(lev[j]>=l&&lev[j]<=r){
				dis[j]=min(dis[j],dis[t]+e[t][j]);
			}
		}
	}
	return dis[1];
}
int main(){
	ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
	cin>>m>>n;
	memset(e,0x3f,sizeof e);
	//for(int i=1;i<=n;i++)e[i][i]=0;
	for(int i=1,a,b,c;i<=n;i++){
		cin>>a>>b>>c;
		e[0][i]=min(e[0][i],a);
		lev[i]=b;
		for(int x,y;c--;){
			cin>>x>>y;
			e[x][i]=min(e[x][i],y);
		}
	}
	int ans=1e5;
	for(int i=lev[1]-m;i<=lev[1];i++)
		ans=min(ans,Dij(i,i+m));
	cout<<ans;
	return 0;
}

*大祺
关注
专栏目录
图论：单源最短路的建图方式（二分 + dijkstra/spfa/双端队列bfs）
m0_66252872的博客
05-24 225
最近考试周，一周多没写题解了。最近两天题都刷不成~ε=(´ο｀*)))唉。 今天抽时间做了几道题，这道题我觉得学习价值很大，囊括了很多的知识点，并且本题的建图方式也值得学习。分享给大家~ 🎁题目:通信线路 在郊区有N座通信基站，P条双向电缆，第i条电缆连接基站 Ai和 Bi。 特别地，1号基站是通信公司的总站，N号基站位于一座农场中。 现在，农场主希望对通信线路进行升级，其中升级第i条电缆需要花费Li。 电话公司正在举行优惠活动。 农产主可以指定一条从1号基...
HDU5521 Meeting(dijkstra+巧妙建图)
think_twcie的博客
07-17 195
HDU5521 Meeting 题意： 给你n个点，它们组成了m个团，第i个团内有si个点，且每个团内的点互相之间距离为ti，问如果同时从点1和点n出发，最短耗时多少相遇 很明显题目给出的是个无负环的图，且要跑出单源最短路，那不就是个dij吗 大方向定下，但图该怎么建呢？ way1: 给每个团内的所有点两两暴力建边 如图所示：黑的为点，红的为团，相同颜色的边长度相等 共∑i=1m12si...
HDU 2680 Choose the best route（Dijkstra，建图的方式很巧妙）
Java识堂，一个有干货的微信公众号
10-16 383
题目地址：点击打开链接 题意：有一个人去他 思路：在HDU2066的基础上变的简单了，那道题是双向图，这道题是单向图，害我wrong了好几发，有2种建图方式（1）把小明的家编号为0，把和他家相邻的车站之间的距离设为0，这样最短距离一定会经过他家相邻的车站（2）反向建图，求从小明朋友家到小明家附近车站的最短距离，这个就和模板差不多了，建图的时候注意反向建图 AC代码1： #include
图 （Dijkstra）
Harington的博客
03-01 731
有向图代码 无向图代代码 邻接矩阵比较简单就直接开一个二维数组就OK 邻接表可以用vector，因为vector是个变长数组嘛， vector&lt;int&gt; Adj[N]; 可以设置出度邻接表，或者入度邻接表 如果需要权值。那就弄个结构体嘛 struct Node{ int v; //边的终点编号 int w; //边权 }; vector&lt;Node&gt;...
单源最短路的建图方式
m0_57193124的博客
05-31 130
题目1：热浪 分析： 由题目可知，求的是两个点之间的最短距离，边权为正数且点数和边数属于同一量级，使用堆优化版的dijkstra进行求解即可。 这道题是无向图，我们建有向图能求解吗？ 不能。 因为如果a 和 b有一条边， 我们只建一条有向边， 意味着 a能到b, b确不能到a， 如果输入时起点是b，终点是a，那么我们就到达不了a，答案出错。 关于能否只建有向图求解无向图的问题， 一定要证明，如果证明不出来，直接按题目要求建立无向图。 时间复杂度：O(m∗logm)O(m * log ^m)O(m∗logm)
【AcWing算法提高课】3.1.1单源最短路的建图方式
最新发布
m0_71477690的博客
01-23 124
AcWing算法提高课 3.1.1单源最短路的建图方式
【基础算法】【ACM】差分约束系统与最短路算法
foreyes_1001的博客
11-19 763
朴素差分约束系统的求解 朴素的差分约束系统是一个不等式组的集合，集合中每一个不等式都形如Ai – Aj &lt;= Xk。对差分约束系统的求解也就是要对不等式组求得任意一组或者满足某种最优性质的一组可行解。差分约束系统在各种计算机和实际的调度问题中都有应用，也可以对某些优化问题的求解提供帮助。   最朴素的差分约束系统可以将不等式组的求解转换成有向图上的单源最短路求解问题，可以利用Dijks...
单源路径算法（Dijkstra、Bellman Ford）（Java邻接表、邻接矩阵、类实现）
a352629619的博客
04-25 1396
单源路径算法（Dijkstra、Bellman Ford）Java 多种存储方式实现
图论：最优乘车
一个努力练习代码的小菜鸟的博客
12-16 569
HH城是一个旅游胜地，每年都有成千上万的人前来观光。 为方便游客，巴士公司在各个旅游景点及宾馆，饭店等地都设置了巴士站并开通了一些单程巴士线路。 每条单程巴士线路从某个巴士站出发，依次途经若干个巴士站，最终到达终点巴士站。 一名旅客最近到HH城旅游，他很想去SS公园游玩，但如果从他所在的饭店没有一路巴士可以直接到达SS公园，则他可能要先乘某一路巴士坐几站，再下来换乘同一站台的另一路巴士，这样换乘几次后到达SS公园。 现在用整数1,2,…N1,2,…N给HH城的所有的巴士站编...
HDU - 4725 (堆优化dijkstra + 虚拟点建图)
Belief_7
09-30 203
题面链接 思路： 一开始以为所有的点所在的层都不同，就一直wa，后面改成存每一层的点，再算每一层的点与上下两层点的距离，结果显然会超时，看了题解后才了解了一个神奇的建图方法可以大大降低算法复杂度。 建图思路： 对于每一层可以抽象为一个点，为了避免与给出点冲突第 i 层抽象为为第 i+n 点，每一层到达本层点的距离都是 0，层中每个点到达上一层点或下一层点的距离都为 c，这样就可以通过虚拟出来的层点实现每个点 i 到达上或下一层任一的点的操作，然后再将额外边加入，跑一遍堆优化的dijkstra即可 代码： #
Subway（建图 + dijkstra算法）
自渡的博客
08-14 552
You have just moved from a quiet Waterloo neighbourhood to a big, noisy city. Instead of getting to ride your bike to school every day, you now get to walk and take the subway. Because you don't want ...
dijkstra板子
anonymity
09-09 650
由于昨天没有更到足够数量的博客，今天又不能拖更。所以我选择来更一篇板子聊表心意 #include&amp;lt;cstdio&amp;gt; #include&amp;lt;cstring&amp;gt; #include&amp;lt;cmath&amp;gt; #include&amp;lt;algorithm&amp;gt; #include&amp;lt;iostream&amp;gt; usin
Dijkstra 板子（效率对比）
辣鸡葫芦娃
08-23 758
测试题目：luogu 1462：二分+Dijkstra 保证了尽可能除了Dijkstra的存图方式不同，其他部分完全相同。 比较结果：vector链表比模拟链表慢大约1/4 板子1号：手动模拟链表版 最慢测试点：420ms 总时间：1984ms #include using namespace std; const int MAX = 1e5; int first[MAX]; in
dijkstra堆优化 板子
qq_62886369的博客
06-13 323
堆优化的dijkstra
dijkstra Floyd 迪杰斯特拉 弗洛伊德 板子
Florentino107的博客
04-07 251
好久没写dijkstra了，找个板子，记录一下，方便用 朴素dijkstra #include<iostream> #include<cstring> #include<algorithm> #include<queue> using namespace std; const int N=3000; int g[N][N],dist[N]; int n,m,s,e; bool st[N]; int dijkstra(int s,int e) { mem
Dijkstra 最短路径板子 青春版 仅供参考 慎入
做一做笔记，做一做总结
08-02 1481
Dijkstra算法是最短路径里常用的一种算法，在邻接矩阵中，n个点，时间复杂度为O(n^2)。 再次强调，此板子本人使用次数也较少，仅供参考，如果看不懂注释，不明就里，最好去参考参考更好的。 int n; const long long inf = __LONG_LONG_MAX__; struct NODE { int u, v, next; // u、v两个点，next链式前...
单源最短路算法详解：Dijkstra方法与应用
在ACM图论和数据结构的背景下，"方法单源最短路(Dijkstra)"是一种核心算法，用于求解有向加权图中的最短路径问题。它在实际应用中具有广泛的用途，例如在旅行规划、交通网络分析、通信网络设计等场景中，寻找两点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值