链式前向星+Dijkstra优先队列优化(应该挺有用)

在这里插入图片描述
这题就是找树上两个点之间的距离,然后这距离是奇数就输出Yes,是偶数就输出No。可以用链式前向星+队列优化的Dijkstra解决,至于队列优化的Dijkstra算法时间复杂度好像是O(nlogn+m),但是其原理我还理解的不够透彻,等以后理解透彻后再对这篇博客进行修改。
下面直接放代码:

#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>
#include<vector> 
using namespace std;
//-----------------------------链式前向星的准备工作-----------------------------------
struct edge{
	int next;//上个以这条边为起点的边在存放边的数组中的位置(方便遍历) 
	int to;//终点 
	int w;//边权 
}dat[200005];//存放边的结构体(无向边大小要开2倍)
int cnt=1;//这是遍历存放边的数组用的,同时也记录着边的数量 
int head[200005];//head[u]表示以u为起点的第一条边(这里第一条指的是链式结构的头)在存放边的数组中的位置 ,无向边大小要开二倍 
void add(int u,int v,int w)//加边函数 
{
	dat[cnt].w=w;//存放边权 
	dat[cnt].to=v;//存放终点 
	dat[cnt].next=head[u];//当前边指向上一条同起点的边 
	head[u]=cnt++;//改变头结点为当前边(方便以后遍历) 
}
//------------------------------------------------------------------------------------
//-------------------------------Dijkstra(单调队列优化)的准备工作-----------------------------------
const int inf = 0x3f3f3f3f;
int dis[100005];
struct cmpx
{
	bool operator() (int &a,int &b) const
	{
		return dis[a]>dis[b];
	}
};//优先队列的排序方式 
//------------------------------------------------------------------------------------
void Dijkstra(int x)
{
	priority_queue<int,vector<int>,cmpx > q;
	memset(dis,0x3f,sizeof(dis));//刚开始x到各点的最短距离都不确定,全部初始化为inf 
	dis[x]=0;//自己到自己的最小距离是0 
	q.push(x);//确定最小距离的点扔进优先队列中 
	while(!q.empty())//队列不为空说明还有点没有确定最小距离,就要继续进行循环 
	{
		int u=q.top();//用队首的点松弛其它与其相邻的边? 
		q.pop();//出列代表我准备用它松弛了其它与其相邻的边? 
		for(int k=head[u];k!=0;k=dat[k].next)//遍历与队首相连的边 
		{
			int v=dat[k].to;
			if(dis[v]>dis[u]+dat[k].w)
			{
				dis[v]=dis[u]+dat[k].w;//能松弛就更新 
				q.push(v);//然后把被松弛的边的终点扔进优先队列中 
			}
		}
	}
}
int main()
{
	int n,a,b;
	cin>>n;
	for(int i=1;i<n;++i)
	{
		cin>>a>>b;
		add(a,b,1);
		add(b,a,1);//无向边 
	}
	cin>>a>>b;
	Dijkstra(a);
	if(dis[b]%2==1) cout<<"Yes"<<endl;
	else cout<<"No"<<endl;
	return 0;
}
### Dijkstra算法与链式前向星的结合实现 #### 背景介绍 Dijkstra算法是一种经典的单源最短路径算法,适用于带权重的有向图。它通过维护一个距离数组 `dist[]` 来记录从起点到其他各点的当前最小距离,并不断更新这些值直到找到全局最优解[^3]。 链式前向星则是一种高效的存储图的方式,类似于邻接表但更加节省空间和易于实现。它的核心思想是利用链表的思想来存储每条边的信息,从而减少内存消耗并提高访问效率[^2]。 当两者结合时,可以通过链式前向星快速读取图中的边信息,而Dijkstra算法负责计算最短路径。为了进一步提升性能,通常会引入优先队列优化,使得每次都能高效选取当前未处理节点中具有最小临时距离的一个节点[^4]。 以下是具体实现方法: --- #### 数据结构设计 1. **边结构定义** 定义一条边的数据结构,包含三个主要成员变量:终点编号 (`to`)、权值 (`weight`) 和下一条边的位置索引 (`next`)。 ```cpp struct Edge { int to; // 边的目标顶点 int weight; // 边的权值 (即长度) int next; // 下一条边在 edges 数组中的位置 }; ``` 2. **辅助数组** - `head[]`: 记录每个节点的第一条边在 `edges` 数组中的起始位置。 - `edges[]`: 存储所有的边信息。 - `cnt`: 当前已有的边数量计数器。 --- #### 构建图的过程 初始化阶段需完成如下操作: - 初始化 `head[]` 数组为 `-1` 表示初始状态下没有任何边连接至任何节点; - 对于输入的每一条新边 `(u, v)` 及其对应的权值 `w` ,将其加入数据结构中。 ```cpp // 添加边 u -> v 的函数 void addEdge(int from, int to, int weight) { edges[cnt].to = to; edges[cnt].weight = weight; edges[cnt].next = head[from]; // 将该边链接到头结点之后 head[from] = cnt++; // 更新头指针指向最新添加的这条边 } ``` 上述过程实现了动态增加边的功能,其中每一次调用都会把新增加的一条边挂载到对应出发点所关联的所有边上形成一个新的链条顶端[^5]。 --- #### 主要逻辑流程 基于以上准备好的基础架构之上执行标准版或者堆优化版本的迪杰斯特拉搜索即可得到最终结果。下面给出完整的C++代码样例展示整个过程: ```cpp #include <bits/stdc++.h> using namespace std; const int MAXN = 1e5 + 7; // 最大可能存在的顶点数目 int dist[MAXN], vis[MAXN]; struct Edge { // 边结构体 int to, weight, next; } edges[2 * MAXN]; int n, m, s, t, cnt, head[MAXN]; // 加入边的方法 void addEdge(int from, int to, int w){ edges[cnt].to=to; edges[cnt].weight=w; edges[cnt].next=head[from]; head[from]=cnt++; } priority_queue<pair<int,int>,vector<pair<int,int>>,greater<pair<int,int>>> pq;//小根堆 void dijkstra(){ memset(dist,0x3f,sizeof(dist)); memset(vis,0,sizeof(vis)); dist[s]=0;pq.push({0,s}); while(!pq.empty()){ pair<int,int> cur=pq.top();pq.pop(); int d=cur.first,u=cur.second; if(vis[u])continue; vis[u]=true; for(int i=head[u];i!=-1;i=edges[i].next){ int v=edges[i].to,w=edges[i].weight; if(!vis[v] && dist[v]>dist[u]+w){ dist[v]=dist[u]+w; pq.push({dist[v],v}); } } } } int main() { cin>>n>>m>>s>>t; memset(head,-1,sizeof(head));cnt=0; for(int i=0;i<m;i++){ int a,b,c; scanf("%d%d%d",&a,&b,&c); addEdge(a,b,c); } dijkstra(); cout <<(dist[t]==INT_MAX?-1:dist[t]); return 0; } ``` 此程序片段展示了如何运用链式前向星配合优先级队列加速后的Dijkstra算法寻找两点间最短路径的实际应用案例。 --- #### 性能分析 相比于传统的矩阵表示方式,这种方法极大地减少了不必要的比较次数;借助二叉堆等高级容器还能让提取下一个最近邻居的操作变得极为迅速,整体时间复杂度降到了 O((V+E)*log(V)) 水平之下。 ---
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值