dijkstra+链式前向星存图+队列优化

本文深入探讨了Dijkstra算法的原理与应用,通过详细解释并提供C++代码实现,帮助读者理解如何寻找加权图中两点之间的最短路径。算法采用优先队列优化效率,适用于解决实际问题。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

#include<bits/stdc++.h>
using namespace std;
#define inf 0x3f3f3f3f
const int maxn=2e5+9;
struct node{
    int next,to,w;
}edge[maxn];
int head[maxn],dis[maxn],cnt=1;
typedef pair<int,int>pr;
inline void add(int u,int v,int w){
    edge[cnt].next=head[u];
    edge[cnt].to=v;
    edge[cnt].w=w;
    head[u]=cnt++;
}
void djk(int v){
    dis[v]=0;
    priority_queue<pr,vector<pr>,greater<pr> >q;
    q.push(pr(dis[v],v));
    while(!q.empty()){
        pr p=q.top();
        q.pop();
        int u=p.second;
        if(dis[u]<p.first)continue;
        dis[u]=p.first;
        for(int i=head[u];i!=-1;i=edge[i].next){
            node e=edge[i];
            if(e.w+dis[u]<dis[e.to]){
                dis[e.to]=e.w+dis[u];
                q.push(pr(dis[e.to],e.to));
            }
        }
    }
}
int main(){
    ios::sync_with_stdio(0);
    cin.tie(0);
    int i,j,k,n,m,s;
    cin>>n>>m>>s;
    memset(dis,inf,sizeof(dis));
    memset(head,-1,sizeof(head));
    while(m--){
        int u,v,w;
        cin>>u>>v>>w;
        add(u,v,w);
    }
    djk(s);
    for(i=1;i<=n;i++){
        if(i!=n)
        cout<<dis[i]<<' ';
        else{
        cout<<dis[i]<<endl;}
    }
}
#include<bits/stdc++.h>
using namespace std;
#define inf 0x3f3f3f3f
const int maxn=2e5+9;
struct node{
    int next,to,w;
}edge[maxn];
int head[maxn],dis[maxn],cnt=1,vis[maxn];
typedef pair<int,int>pr;
inline void add(int u,int v,int w){
    edge[cnt].next=head[u];
    edge[cnt].to=v;
    edge[cnt].w=w;
    head[u]=cnt++;
}
void djk(int v){
    dis[v]=0;
    priority_queue<pr,vector<pr>,greater<pr> >q;
    q.push(pr(dis[v],v));
    while(!q.empty()){
        pr p=q.top();
        q.pop();
        int u=p.second;
        if(vis[u])continue;
        vis[u]=1;
        dis[u]=p.first;
        for(int i=head[u];i!=-1;i=edge[i].next){
            node e=edge[i];
            if(vis[e.to])continue;
            if(e.w+dis[u]<dis[e.to]){
                dis[e.to]=e.w+dis[u];
                q.push(pr(dis[e.to],e.to));
            }
        }
    }
}
int main(){
    ios::sync_with_stdio(0);
    cin.tie(0);
    int i,j,k,n,m,s;
    cin>>n>>m>>s;
    memset(dis,inf,sizeof(dis));
    memset(head,-1,sizeof(head));
    while(m--){
        int u,v,w;
        cin>>u>>v>>w;
        add(u,v,w);
    }
    djk(s);
    for(i=1;i<=n;i++){
        if(i!=n)
        cout<<dis[i]<<' ';
        else{
        cout<<dis[i]<<endl;}
    }
}

测试题:https://www.luogu.org/problemnew/show/P4779

 

### 使用堆优化Dijkstra算法在C++中的实现 Dijkstra算法的核心在于逐步扩展当前已知的短路径,而为了提高效率,可以利用优先队列小堆)来速选取下一个待处理的节点的过程。以下是基于堆优化Dijkstra算法在C++中的具体实现。 #### 1. 算法概述 传统的Dijkstra算法通过线性扫描的方式寻找距离起点近的未访问节点,时间复杂度为 \(O(V^2)\),其中 \(V\) 是中顶点的数量。当使用二叉堆作为优先队列时,可以在 \(O(\log V)\) 的时间内完成插入和删除操作,从而将总的时间复杂度降低至 \(O((E+V)\log V)\)[^2],其中 \(E\) 表示中边的数量。 #### 2. C++ 实现代码 下面是一个完整的堆优化Dijkstra 算法的 C++ 实现: ```cpp #include <iostream> #include <vector> #include <queue> #include <climits> using namespace std; struct Edge { int to; long long weight; }; // 定义一个小根堆比较函数 struct Compare { bool operator()(const pair<long long, int>& a, const pair<long long, int>& b) { return a.first > b.first; // 按照距离从小到大排列 } }; void dijkstra(int start, vector<vector<Edge>>& adjList, vector<long long>& dist) { priority_queue<pair<long long, int>, vector<pair<long long, int>>, Compare> pq; // 初始化距离数组 for (int i = 0; i < dist.size(); ++i) { dist[i] = LLONG_MAX; } dist[start] = 0; pq.push({0, start}); while (!pq.empty()) { auto current = pq.top(); pq.pop(); int u = current.second; long long d = current.first; // 如果已经找到了更优的距离,则跳过此节点 if (d > dist[u]) continue; // 遍历相邻节点并尝试更新距离 for (auto& edge : adjList[u]) { int v = edge.to; long long w = edge.weight; if (dist[v] > dist[u] + w) { // 松弛操作 dist[v] = dist[u] + w; pq.push({dist[v], v}); } } } } int main() { int n, m, s; cin >> n >> m >> s; // 输入节点数、边数以及起点编号 vector<vector<Edge>> adjList(n + 1); // 邻接表表示 for (int i = 0; i < m; ++i) { int from, to, weight; cin >> from >> to >> weight; adjList[from].push_back(Edge{to, weight}); // 单向边 } vector<long long> dist(n + 1); dijkstra(s, adjList, dist); // 输出结果 for (int i = 1; i <= n; ++i) { cout << "Distance from source to node " << i << ": "; if (dist[i] == LLONG_MAX) { cout << "INF\n"; // 若不可达则输出 INF } else { cout << dist[i] << "\n"; } } return 0; } ``` #### 3. 关键点解析 - **数据结构的选择** 使用 `priority_queue` 和自定义比较器实现了小堆的功能,能够快速获取当前距离起点近的节点[^4]。 - **松弛操作** 当发现一条新的路径使得目标节点的距离变得更小时,立即更新其距离值,并将其入优先队列以便后续进一步探索[^3]。 - **性能提升** 利用堆优化后的版本显著减少了不必要的重复计算,在稀疏上的表现尤为突出。 --- ###
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值